@eleven-am/pondsocket 0.1.142 → 0.1.143

package/abstracts/abstractRequest.js

@@ -42,8 +42,7 @@ class AbstractRequest {
         return this._engine.getAssigns();
     }
     get presence() {
-        var _a;
-        return ((_a = this._engine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()) || {};
+        return this._engine.presenceEngine.getPresence();
     }
     /**
      * @desc Parses the event and returns true if the event matches the path

package/abstracts/abstractRequest.test.js

@@ -1,11 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const abstractRequest_1 = require("./abstractRequest");
-const createMockChannelEngine = () => ({
-    name: 'test',
-    getAssigns: () => ({}),
-    getPresence: () => ({}),
-});
+const eventResponse_test_1 = require("../channel/eventResponse.test");
+const createMockChannelEngine = () => (0, eventResponse_test_1.createChannelEngine)().channelEngine;
 describe('AbstractRequest', () => {
     it('should be able to be instantiated', () => {
         const request = new abstractRequest_1.AbstractRequest('/test', createMockChannelEngine(), {});

package/channel/channel.js

@@ -21,62 +21,14 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var _Channel_engine, _ChannelEngine_instances, _ChannelEngine_receiver, _ChannelEngine_presenceEngine, _ChannelEngine_users, _ChannelEngine_parentEngine, _ChannelEngine_subscribe, _ChannelEngine_getUsersFromRecipients, _ChannelEngine_buildSubscription, _ChannelEngine_removeUser;
+var _ChannelEngine_instances, _ChannelEngine_receiver, _ChannelEngine_presenceEngine, _ChannelEngine_users, _ChannelEngine_parentEngine, _ChannelEngine_subscribe, _ChannelEngine_getUsersFromRecipients, _ChannelEngine_buildSubscription, _ChannelEngine_removeUser, _Channel_engine;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChannelEngine = exports.Channel = void 0;
+exports.Channel = exports.ChannelEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const eventRequest_1 = require("./eventRequest");
 const eventResponse_1 = require("./eventResponse");
 const pondError_1 = require("../errors/pondError");
 const presence_1 = require("../presence/presence");
-class Channel {
-    constructor(engine) {
-        _Channel_engine.set(this, void 0);
-        __classPrivateFieldSet(this, _Channel_engine, engine, "f");
-    }
-    get name() {
-        return __classPrivateFieldGet(this, _Channel_engine, "f").name;
-    }
-    getAssigns() {
-        return __classPrivateFieldGet(this, _Channel_engine, "f").getAssigns();
-    }
-    getPresences() {
-        return __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.getPresence();
-    }
-    getUserData(userId) {
-        return __classPrivateFieldGet(this, _Channel_engine, "f").getUserData(userId);
-    }
-    broadcast(event, payload) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
-    }
-    broadcastFrom(userId, event, payload) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(userId, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
-    }
-    broadcastTo(userIds, event, payload) {
-        const users = Array.isArray(userIds) ? userIds : [userIds];
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, users, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
-    }
-    evictUser(userId, reason) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").kickUser(userId, reason !== null && reason !== void 0 ? reason : 'You have been banned from the channel');
-    }
-    trackPresence(userId, presence) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.trackPresence(userId, presence);
-    }
-    removePresence(userId) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.removePresence(userId);
-    }
-    updatePresence(userId, presence) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.updatePresence(userId, presence);
-    }
-    subscribeTo(userId, channel) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").subscribeTo(userId, channel);
-    }
-    unsubscribeFrom(userId, channel) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").unsubscribeFrom(userId, channel);
-    }
-}
-exports.Channel = Channel;
-_Channel_engine = new WeakMap();
 class ChannelEngine {
     constructor(name, parent) {
         _ChannelEngine_instances.add(this);
@@ -297,6 +249,7 @@ _ChannelEngine_receiver = new WeakMap(), _ChannelEngine_presenceEngine = new Wea
     const userPresence = (_a = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) === null || _a === void 0 ? void 0 : _a.removePresence(userId);
     if (__classPrivateFieldGet(this, _ChannelEngine_parentEngine, "f").leaveCallback) {
         __classPrivateFieldGet(this, _ChannelEngine_parentEngine, "f").leaveCallback({
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
             channel: new Channel(this),
             user: {
                 id: userId,
@@ -317,3 +270,51 @@ _ChannelEngine_receiver = new WeakMap(), _ChannelEngine_presenceEngine = new Wea
     unsubscribe();
     cachedUser.subscriptions.delete(this.name);
 };
+class Channel {
+    constructor(engine) {
+        _Channel_engine.set(this, void 0);
+        __classPrivateFieldSet(this, _Channel_engine, engine, "f");
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _Channel_engine, "f").name;
+    }
+    getAssigns() {
+        return __classPrivateFieldGet(this, _Channel_engine, "f").getAssigns();
+    }
+    getPresences() {
+        return __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.getPresence();
+    }
+    getUserData(userId) {
+        return __classPrivateFieldGet(this, _Channel_engine, "f").getUserData(userId);
+    }
+    broadcast(event, payload) {
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+    }
+    broadcastFrom(userId, event, payload) {
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(userId, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+    }
+    broadcastTo(userIds, event, payload) {
+        const users = Array.isArray(userIds) ? userIds : [userIds];
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, users, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+    }
+    evictUser(userId, reason) {
+        __classPrivateFieldGet(this, _Channel_engine, "f").kickUser(userId, reason !== null && reason !== void 0 ? reason : 'You have been banned from the channel');
+    }
+    trackPresence(userId, presence) {
+        __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.trackPresence(userId, presence);
+    }
+    removePresence(userId) {
+        __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.removePresence(userId);
+    }
+    updatePresence(userId, presence) {
+        __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.updatePresence(userId, presence);
+    }
+    subscribeTo(userId, channel) {
+        __classPrivateFieldGet(this, _Channel_engine, "f").subscribeTo(userId, channel);
+    }
+    unsubscribeFrom(userId, channel) {
+        __classPrivateFieldGet(this, _Channel_engine, "f").unsubscribeFrom(userId, channel);
+    }
+}
+exports.Channel = Channel;
+_Channel_engine = new WeakMap();

package/channel/eventResponse.js

@@ -119,6 +119,7 @@ class EventResponse {
      */
     evictUser(reason, userId = __classPrivateFieldGet(this, _EventResponse_event, "f").sender) {
         __classPrivateFieldGet(this, _EventResponse_engine, "f").kickUser(userId, reason);
+        return this;
     }
     /**
      * @desc Closes the channel from the server side for all clients

package/endpoint/response.js

@@ -37,6 +37,20 @@ class ConnectionResponse {
     get hasResponded() {
         return __classPrivateFieldGet(this, _ConnectionResponse_executed, "f");
     }
+    /**
+     * @desc Assigns data to the user
+     * @param assigns - the data to assign
+     */
+    assign(assigns) {
+        if (!__classPrivateFieldGet(this, _ConnectionResponse_executed, "f")) {
+            __classPrivateFieldSet(this, _ConnectionResponse_assigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _ConnectionResponse_assigns, "f")), assigns), "f");
+        }
+        else {
+            const user = __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").getUser(__classPrivateFieldGet(this, _ConnectionResponse_clientId, "f"));
+            user.assigns = Object.assign(Object.assign({}, user.assigns), assigns);
+        }
+        return this;
+    }
     /**
      * @desc Accepts the join request
      */
@@ -52,20 +66,6 @@ class ConnectionResponse {
         __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").manageSocket(cache);
         return this;
     }
-    /**
-     * @desc Assigns data to the user
-     * @param assigns - the data to assign
-     */
-    assign(assigns) {
-        if (!__classPrivateFieldGet(this, _ConnectionResponse_executed, "f")) {
-            __classPrivateFieldSet(this, _ConnectionResponse_assigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _ConnectionResponse_assigns, "f")), assigns), "f");
-        }
-        else {
-            const user = __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").getUser(__classPrivateFieldGet(this, _ConnectionResponse_clientId, "f"));
-            user.assigns = Object.assign(Object.assign({}, user.assigns), assigns);
-        }
-        return this;
-    }
     /**
      * @desc Rejects the request with the given error message
      * @param message - the error message

package/lobby/joinResponse.js

@@ -35,6 +35,19 @@ class JoinResponse {
     get hasResponded() {
         return __classPrivateFieldGet(this, _JoinResponse_executed, "f");
     }
+    /**
+     * @desc Assigns data to the client
+     * @param assigns - the data to assign
+     */
+    assign(assigns) {
+        if (__classPrivateFieldGet(this, _JoinResponse_accepted, "f")) {
+            __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;
+    }
     /**
      * @desc Accepts the join request to the channel
      */
@@ -75,19 +88,6 @@ class JoinResponse {
         __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(errorMessage));
         return this;
     }
-    /**
-     * @desc Assigns data to the client
-     * @param assigns - the data to assign
-     */
-    assign(assigns) {
-        if (__classPrivateFieldGet(this, _JoinResponse_accepted, "f")) {
-            __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;
-    }
     /**
      * @desc Emits a direct message to the client
      * @param event - the event name

package/lobby/lobby.js

@@ -147,46 +147,15 @@ class PondChannel {
         _PondChannel_lobby.set(this, void 0);
         __classPrivateFieldSet(this, _PondChannel_lobby, lobby, "f");
     }
-    /**
-     * @desc Handles an event request made by a user
-     * @param event - The event to listen for
-     * @param handler - The handler to execute when the event is received
-     * @example
-     * pond.onEvent('echo', (request, response) => {
-     *     response.send('echo', {
-     *         message: request.event.payload,
-     *     });
-     * });
-     */
     onEvent(event, handler) {
         __classPrivateFieldGet(this, _PondChannel_lobby, "f").onEvent(event, handler);
     }
-    /**
-     * @desc Broadcasts a message to all users in a channel
-     * @param event - The event to broadcast
-     * @param payload - The payload to send
-     * @param channelName - The channel to broadcast to (if not specified, broadcast to all channels)
-     * @example
-     * pond.broadcast('echo', {
-     *    message: 'Hello World',
-     *    timestamp: Date.now(),
-     *    channel: 'my_channel',
-     *});
-     */
     broadcast(event, payload, channelName) {
         __classPrivateFieldGet(this, _PondChannel_lobby, "f").broadcast(event, payload, channelName);
     }
-    /**
-     * @desc Handles the leave event for a user, can occur when a user disconnects or leaves a channel, use this to clean up any resources
-     * @param callback - The callback to execute when a user leaves
-     */
     onLeave(callback) {
         __classPrivateFieldGet(this, _PondChannel_lobby, "f").onLeave(callback);
     }
-    /**
-     * @desc Gets a channel by name
-     * @param channelName - The name of the channel to get
-     */
     getChannel(channelName) {
         const channel = __classPrivateFieldGet(this, _PondChannel_lobby, "f").getChannel(channelName);
         if (channel) {

package/package.json

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

package/server/pondSocket.js

@@ -17,7 +17,7 @@ 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 endpointEngine_1 = require("../endpoint/endpointEngine");
+const endpoint_1 = require("../endpoint/endpoint");
 const response_1 = require("../endpoint/response");
 const matcher_1 = require("../matcher/matcher");
 class PondSocket {
@@ -62,7 +62,7 @@ class PondSocket {
      * })
      */
     createEndpoint(path, handler) {
-        const endpoint = new endpointEngine_1.EndpointEngine(this);
+        const endpoint = new endpoint_1.EndpointEngine(this);
         __classPrivateFieldGet(this, _PondSocket_middleware, "f").use((req, socket, next) => {
             const event = (0, matcher_1.parseAddress)(path, req.address);
             if (event) {
@@ -72,7 +72,7 @@ class PondSocket {
             }
             return next();
         });
-        return new endpointEngine_1.Endpoint(endpoint);
+        return new endpoint_1.Endpoint(endpoint);
     }
 }
 exports.PondSocket = PondSocket;

package/types.d.ts

@@ -22,124 +22,47 @@ export interface LeaveEvent<EventTypes extends PondEventMap = PondEventMap, Pres
 
 export type LeaveCallback<EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> = (event: LeaveEvent<EventTypes, PresenceType, AssignType>) => void;
 
-export declare class AbstractRequest<Path extends string, PresenceType extends PondPresence, AssignType extends PondAssigns> {
-    event: PondEvent<Path>;
-
-    channelName: string;
-
-    assigns: Record<string, AssignType>;
-
-    presence: Record<string, PresenceType>;
-}
-
-export declare class EventRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> extends AbstractRequest<Path, PresenceType, AssignType> {
-    user: UserData<PresenceType, AssignType>;
-
-    channel: Channel;
-}
-
-export declare class EventResponse<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
-    /**
-     * @desc Whether the server has responded to the request
-     */
-    hasResponded: boolean;
-
-    /**
-     * Assigns data to the client.
-     * @param {PondAssigns} assigns - The data to assign to the client.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
-     */
-    assign(assigns: AssignType): EventResponse<EventType, PresenceType, AssignType>;
-
-    /**
-     * @desc Emits a direct message to the client.
-     * @param {string} event - The event name.
-     * @param {PondMessage} payload - The payload to send.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
-     */
-    reply<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventResponse<EventType, PresenceType, AssignType>;
-
-    /**
-     * @desc Sends a message to all clients in the channel.
-     * @param {string} event - The event to send.
-     * @param {PondMessage} payload - The payload to send.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
-     */
-    broadcast<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventResponse<EventType, PresenceType, AssignType>;
-
-    /**
-     * @desc Sends a message to all clients in the channel except the client making the request.
-     * @param {string} event - The event to send.
-     * @param {PondMessage} payload - The payload to send.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
-     */
-    broadcastFrom<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent]): EventResponse<EventType, PresenceType, AssignType>;
-
-    /**
-     * @desc Sends a message to a set of clients in the channel.
-     * @param {string} event - The event to send.
-     * @param {PondMessage} payload - The payload to send.
-     * @param {string | string[]} userIds - The ids of the clients to send the message to.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
-     */
-    broadcastTo<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent], userIds: string | string[]): EventResponse<EventType, PresenceType, AssignType>;
-
-    /**
-     * @desc Tracks a user's presence in the channel.
-     * @param {PondPresence} presence - The initial presence data.
-     * @param {string} userId - The id of the user to track.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
-     */
-    trackPresence(presence: PresenceType, userId?: string): EventResponse<EventType, PresenceType, AssignType>;
+export type RequestHandler<Request, Response> = (request: Request, response: Response) => void | Promise<void>;
 
-    /**
-     * @desc Updates a user's presence in the channel.
-     * @param {PondPresence} presence - The updated presence data.
-     * @param {string} userId - The id of the user to update.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
-     */
-    updatePresence(presence: PresenceType, userId?: string): EventResponse;
-
-    /**
-     * @desc Removes a user's presence from the channel.
-     * @param {string} userId - The id of the user to remove.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
-     */
-    removePresence(userId?: string): EventResponse;
-
-    /**
-     * @desc Subscribes the client to a channel.
-     * @param {string} channel - The channel to subscribe to.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
-     */
-    subscribeTo(channel: string): EventResponse;
+export declare class PondSocket {
+    constructor(server?: HTTPServer, socketServer?: WebSocketServer);
 
     /**
-     * @desc Unsubscribes the client from a channel.
-     * @param {string} channel - The channel to unsubscribe from.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
+     * @desc Specifies the port to listen on
+     * @param args - the arguments to pass to the server
      */
-    unsubscribeFrom(channel: string): EventResponse;
+    listen(...args: any[]): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
 
     /**
-     * @desc Evicts a user from the channel.
-     * @param {string} reason - The reason for the eviction.
-     * @param {string} userId - The id of the user to evict.
+     * @desc Closes the server
+     * @param callback - the callback to call when the server is closed
      */
-    evictUser(reason: string, userId?: string): void;
+    close(callback?: () => void): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
 
     /**
-     * @desc Closes the channel from the server side for all clients.
-     * @param {string} reason - The reason for closing the channel.
+     * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
+     * @param path - the pattern to accept || can also be a regex
+     * @param handler - the handler function to authenticate the socket
+     * @example
+     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
+     *    const token = req.query.token;
+     *    if (!token)
+     *       return res.reject('No token provided');
+     *    res.accept({
+     *       assign: {
+     *           token
+     *       }
+     *    });
+     * })
      */
-    closeChannel(reason: string): void;
+    createEndpoint<Path extends string>(path: PondPath<Path>, handler: RequestHandler<IncomingConnection<Path>, ConnectionResponse>): Endpoint;
 }
 
 export declare class Endpoint {
     /**
      * @desc Adds a new PondChannel to this path on this endpoint
      * @param {PondPath<string>} path - The path to add the channel to
-     * @param {ChannelHandler} handler - The handler to use to authenticate the client
+     * @param {RequestHandler} handler - The handler to use to authenticate the client
      * @returns {PondChannel} - The PondChannel instance for the new channel
      *
      * @example
@@ -151,7 +74,7 @@ export declare class Endpoint {
      *         response.reject('You are not an admin', 403);
      * });
      */
-    createChannel<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns>(path: PondPath<Path>, handler: (request: JoinRequest<Path, PresenceType, AssignType>, response: JoinResponse<EventType, PresenceType, AssignType>) => void | Promise<void>): PondChannel<EventType, PresenceType, AssignType>;
+    createChannel<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns>(path: PondPath<Path>, handler: RequestHandler<JoinRequest<Path, PresenceType, AssignType>, JoinResponse<EventType, PresenceType, AssignType>>): PondChannel<EventType, PresenceType, AssignType>;
 
     /**
      * @desc Broadcasts a message to all clients connected to this endpoint
@@ -173,6 +96,54 @@ export declare class Endpoint {
     getClients(): WebSocket[];
 }
 
+export declare class PondChannel<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
+    /**
+     * @desc Handles an event request made by a user
+     * @param {PondPath<string>} event - The event to handle
+     * @param {RequestHandler} handler - The handlers to execute when the event is received
+     * @example
+     * pond.onEvent('echo', (request, response) => {
+     *     response.reply('echo', {
+     *         message: request.event.payload,
+     *     });
+     * });
+     */
+    onEvent<Event extends string>(event: PondPath<Event>, handler: RequestHandler<EventRequest<Event, PresenceType, AssignType>, EventResponse<EventType, PresenceType, AssignType>>): void;
+
+    /**
+     * @desc Broadcasts a message to all users in a channel
+     * @param event - The event to broadcast
+     * @param payload - The payload to send
+     * @param channelName - The channel to broadcast to (if not specified, broadcast to all channels)
+     * @example
+     * pond.broadcast('echo', {
+     *    message: 'Hello World',
+     *    timestamp: Date.now(),
+     *    channel: 'my_channel',
+     *});
+     */
+    broadcast<Key extends keyof EventType>(event: Key, payload: EventType[Key], channelName?: string): void;
+
+    /**
+     * @desc Handles the leave event for a user, can occur when a user disconnects or leaves a channel, use this to clean up any resources
+     * @param {LeaveCallback} callback - The callback to execute when a user leaves
+     * @example
+     * pond.onLeave((event) => {
+     *     // Clean up resources
+     * });
+     */
+    onLeave(callback: LeaveCallback<EventType, PresenceType, AssignType>): void;
+
+    /**
+     * @desc Gets a channel by name
+     * @param {string} channelName - The name of the channel to get
+     * @returns {Channel} - The channel instance
+     * @example
+     * const channel = pond.getChannel('my_channel')!;
+     */
+    getChannel(channelName: string): Channel<EventType, PresenceType, AssignType> | null;
+}
+
 export declare class Channel<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
      * The name of the channel.
@@ -260,6 +231,16 @@ export declare class Channel<EventType extends PondEventMap = PondEventMap, Pres
     unsubscribeFrom(userId: string, channel: string): void;
 }
 
+export declare class AbstractRequest<Path extends string, PresenceType extends PondPresence, AssignType extends PondAssigns> {
+    event: PondEvent<Path>;
+
+    channelName: string;
+
+    assigns: Record<string, AssignType>;
+
+    presence: Record<string, PresenceType>;
+}
+
 export declare class JoinRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> extends AbstractRequest<Path, PresenceType, AssignType> {
     joinParams: JoinParams;
 
@@ -268,6 +249,59 @@ export declare class JoinRequest<Path extends string, PresenceType extends PondP
     channel: Channel;
 }
 
+export declare class EventRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> extends AbstractRequest<Path, PresenceType, AssignType> {
+    user: UserData<PresenceType, AssignType>;
+
+    channel: Channel;
+}
+
+export declare class ConnectionResponse {
+    /**
+     * @desc Whether the server has responded to the request
+     */
+    hasResponded: boolean;
+
+    /**
+     * @desc Assigns data to the user.
+     * @param {PondAssigns} assigns - The data to assign.
+     * @returns {ConnectionResponse} - The ConnectionResponse instance for chaining.
+     */
+    assign(assigns: PondAssigns): ConnectionResponse;
+
+    /**
+     * @desc Accepts the connection request to the endpoint.
+     */
+    accept(): void;
+
+    /**
+     * @desc Rejects the request with the given error message
+     * @param {string} message - The error message
+     * @param {number} errorCode - The error code
+     */
+    decline(message?: string, errorCode?: number): void;
+
+    /**
+     * @desc Emits a direct message to the client
+     * @param {string} event - The event name
+     * @param {PondMessage} payload - The payload to send
+     */
+    reply(event: string, payload: PondMessage): ConnectionResponse;
+
+    /**
+     * @desc Subscribes the client to a channel.
+     * @param {string} channel - The channel to subscribe to.
+     * @returns {ConnectionResponse} - The JoinResponse instance for chaining.
+     */
+    subscribeTo(channel: string): ConnectionResponse;
+
+    /**
+     * @desc Unsubscribes the client from a channel.
+     * @param {string} channel - The channel to unsubscribe from.
+     * @returns {ConnectionResponse} - The JoinResponse instance for chaining.
+     */
+    unsubscribeFrom(channel: string): ConnectionResponse;
+}
+
 export declare class JoinResponse<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
      * @desc Whether the server has responded to the request
@@ -344,128 +378,101 @@ export declare class JoinResponse<EventType extends PondEventMap = PondEventMap,
     unsubscribeFrom(channel: string): JoinResponse;
 }
 
-export declare class ConnectionResponse {
+export declare class EventResponse<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
      * @desc Whether the server has responded to the request
      */
     hasResponded: boolean;
 
     /**
-     * @desc Assigns data to the user.
-     * @param {PondAssigns} assigns - The data to assign.
-     * @returns {ConnectionResponse} - The ConnectionResponse instance for chaining.
-     */
-    assign(assigns: PondAssigns): ConnectionResponse;
-
-    /**
-     * @desc Accepts the connection request to the endpoint.
+     * @desc Assigns data to the client.
+     * @param {PondAssigns} assigns - The data to assign to the client.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    accept(): void;
+    assign(assigns: AssignType): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Rejects the request with the given error message
-     * @param {string} message - The error message
-     * @param {number} errorCode - The error code
+     * @desc Emits a direct message to the client.
+     * @param {string} event - The event name.
+     * @param {PondMessage} payload - The payload to send.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    decline(message?: string, errorCode?: number): void;
+    reply<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Emits a direct message to the client
-     * @param {string} event - The event name
-     * @param {PondMessage} payload - The payload to send
+     * @desc Sends a message to all clients in the channel.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The payload to send.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    reply(event: string, payload: PondMessage): ConnectionResponse;
+    broadcast<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Subscribes the client to a channel.
-     * @param {string} channel - The channel to subscribe to.
-     * @returns {ConnectionResponse} - The JoinResponse instance for chaining.
+     * @desc Sends a message to all clients in the channel except the client making the request.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The payload to send.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    subscribeTo(channel: string): ConnectionResponse;
+    broadcastFrom<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent]): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Unsubscribes the client from a channel.
-     * @param {string} channel - The channel to unsubscribe from.
-     * @returns {ConnectionResponse} - The JoinResponse instance for chaining.
+     * @desc Sends a message to a set of clients in the channel.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The payload to send.
+     * @param {string | string[]} userIds - The ids of the clients to send the message to.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    unsubscribeFrom(channel: string): ConnectionResponse;
-}
+    broadcastTo<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent], userIds: string | string[]): EventResponse<EventType, PresenceType, AssignType>;
 
-export declare class PondChannel<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
-     * @desc Handles an event request made by a user
-     * @param event - The event to listen for
-     * @param handler - The handler to execute when the event is received
-     * @example
-     * pond.onEvent('echo', (request, response) => {
-     *     response.send('echo', {
-     *         message: request.event.payload,
-     *     });
-     * });
+     * @desc Tracks a user's presence in the channel.
+     * @param {PondPresence} presence - The initial presence data.
+     * @param {string} userId - The id of the user to track.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    onEvent<Event extends string>(event: PondPath<Event>, handler: (request: EventRequest<Event, PresenceType, AssignType>, response: EventResponse<EventType, PresenceType, AssignType>) => void | Promise<void>): void;
+    trackPresence(presence: PresenceType, userId?: string): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Broadcasts a message to all users in a channel
-     * @param event - The event to broadcast
-     * @param payload - The payload to send
-     * @param channelName - The channel to broadcast to (if not specified, broadcast to all channels)
-     * @example
-     * pond.broadcast('echo', {
-     *    message: 'Hello World',
-     *    timestamp: Date.now(),
-     *    channel: 'my_channel',
-     *});
+     * @desc Updates a user's presence in the channel.
+     * @param {PondPresence} presence - The updated presence data.
+     * @param {string} userId - The id of the user to update.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    broadcast<Key extends keyof EventType>(event: Key, payload: EventType[Key], channelName?: string): void;
+    updatePresence(presence: PresenceType, userId?: string): EventResponse;
 
     /**
-     * @desc Handles the leave event for a user, can occur when a user disconnects or leaves a channel, use this to clean up any resources
-     * @param {LeaveCallback} callback - The callback to execute when a user leaves
-     * @example
-     * pond.onLeave((event) => {
-     *     // Clean up resources
-     * });
+     * @desc Removes a user's presence from the channel.
+     * @param {string} userId - The id of the user to remove.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    onLeave(callback: LeaveCallback<EventType, PresenceType, AssignType>): void;
+    removePresence(userId?: string): EventResponse;
 
     /**
-     * @desc Gets a channel by name
-     * @param {string} channelName - The name of the channel to get
+     * @desc Subscribes the client to a channel.
+     * @param {string} channel - The channel to subscribe to.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    getChannel(channelName: string): Channel<EventType, PresenceType, AssignType>;
-}
-
-export declare class PondSocket {
-    constructor(server?: HTTPServer, socketServer?: WebSocketServer);
+    subscribeTo(channel: string): EventResponse;
 
     /**
-     * @desc Specifies the port to listen on
-     * @param args - the arguments to pass to the server
+     * @desc Unsubscribes the client from a channel.
+     * @param {string} channel - The channel to unsubscribe from.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    listen(...args: any[]): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
+    unsubscribeFrom(channel: string): EventResponse;
 
     /**
-     * @desc Closes the server
-     * @param callback - the callback to call when the server is closed
+     * @desc Evicts a user from the channel.
+     * @param {string} reason - The reason for the eviction.
+     * @param {string} userId - The id of the user to evict.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    close(callback?: () => void): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
+    evictUser(reason: string, userId?: string): EventResponse;
 
     /**
-     * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
-     * @param path - the pattern to accept || can also be a regex
-     * @param handler - the handler function to authenticate the socket
-     * @example
-     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
-     *    const token = req.query.token;
-     *    if (!token)
-     *       return res.reject('No token provided');
-     *    res.accept({
-     *       assign: {
-     *           token
-     *       }
-     *    });
-     * })
+     * @desc Closes the channel from the server side for all clients.
+     * @param {string} reason - The reason for closing the channel.
      */
-    createEndpoint<Path extends string>(path: PondPath<Path>, handler: (request: IncomingConnection<Path>, response: ConnectionResponse) => void | Promise<void>): Endpoint;
+    closeChannel(reason: string): void;
 }
+