@eleven-am/pondsocket 0.1.214 → 0.1.215

package/abstracts/distributor.d.ts

@@ -0,0 +1,13 @@
+import { Unsubscribe } from '@eleven-am/pondsocket-common';
+import { DistributedChannelMessage, IDistributedBackend, RedisDistributedBackendOptions } from '../types';
+export declare class RedisDistributedBackend implements IDistributedBackend {
+    #private;
+    get nodeId(): string;
+    get heartbeatTimeoutMs(): number;
+    constructor(options?: RedisDistributedBackendOptions);
+    subscribeToChannel(endpointName: string, channelName: string, handler: (message: DistributedChannelMessage) => void): Promise<Unsubscribe>;
+    subscribeToHeartbeats(handler: (nodeId: string) => void): Unsubscribe;
+    broadcast(endpointName: string, channelName: string, message: DistributedChannelMessage): Promise<void>;
+    cleanup(): Promise<void>;
+    initialize(): Promise<void>;
+}

package/abstracts/distributor.js

@@ -8,84 +8,113 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _RedisDistributedBackend_instances, _RedisDistributedBackend_publishClient, _RedisDistributedBackend_subscribeClient, _RedisDistributedBackend_keyPrefix, _RedisDistributedBackend_subject, _RedisDistributedBackend_nodeId, _RedisDistributedBackend_isConnected, _RedisDistributedBackend_initialize, _RedisDistributedBackend_handleRedisMessage, _RedisDistributedBackend_isValidMessage, _RedisDistributedBackend_buildKey;
+var _RedisDistributedBackend_instances, _RedisDistributedBackend_publishClient, _RedisDistributedBackend_subscribeClient, _RedisDistributedBackend_keyPrefix, _RedisDistributedBackend_heartbeatSubject, _RedisDistributedBackend_nodeId, _RedisDistributedBackend_heartbeatIntervalMs, _RedisDistributedBackend_heartbeatTimeoutMs, _RedisDistributedBackend_onError, _RedisDistributedBackend_isConnected, _RedisDistributedBackend_heartbeatTimer, _RedisDistributedBackend_attachEventHandlers, _RedisDistributedBackend_startHeartbeat, _RedisDistributedBackend_publishHeartbeat, _RedisDistributedBackend_handleHeartbeatMessage, _RedisDistributedBackend_isValidMessage, _RedisDistributedBackend_buildKey;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisDistributedBackend = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const redis_1 = require("redis");
-const types_1 = require("./types");
+const types_1 = require("../types");
 class RedisDistributedBackend {
+    get nodeId() {
+        return __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f");
+    }
+    get heartbeatTimeoutMs() {
+        return __classPrivateFieldGet(this, _RedisDistributedBackend_heartbeatTimeoutMs, "f");
+    }
     constructor(options = {}) {
         _RedisDistributedBackend_instances.add(this);
         _RedisDistributedBackend_publishClient.set(this, void 0);
         _RedisDistributedBackend_subscribeClient.set(this, void 0);
         _RedisDistributedBackend_keyPrefix.set(this, void 0);
-        _RedisDistributedBackend_subject.set(this, void 0);
+        _RedisDistributedBackend_heartbeatSubject.set(this, void 0);
         _RedisDistributedBackend_nodeId.set(this, void 0);
+        _RedisDistributedBackend_heartbeatIntervalMs.set(this, void 0);
+        _RedisDistributedBackend_heartbeatTimeoutMs.set(this, void 0);
+        _RedisDistributedBackend_onError.set(this, void 0);
         _RedisDistributedBackend_isConnected.set(this, false);
-        const { host = 'localhost', port = 6379, password, database = 0, url, keyPrefix = 'pondsocket', } = options;
+        _RedisDistributedBackend_heartbeatTimer.set(this, null);
+        const { host = 'localhost', port = 6379, password, database = 0, url, keyPrefix = 'pondsocket', heartbeatIntervalMs = 30000, heartbeatTimeoutMs = 90000, onError = null, } = options;
         __classPrivateFieldSet(this, _RedisDistributedBackend_keyPrefix, keyPrefix, "f");
+        __classPrivateFieldSet(this, _RedisDistributedBackend_heartbeatIntervalMs, heartbeatIntervalMs, "f");
+        __classPrivateFieldSet(this, _RedisDistributedBackend_heartbeatTimeoutMs, heartbeatTimeoutMs, "f");
+        __classPrivateFieldSet(this, _RedisDistributedBackend_onError, onError, "f");
         __classPrivateFieldSet(this, _RedisDistributedBackend_nodeId, Math.random().toString(36)
             .substring(2, 15), "f");
-        __classPrivateFieldSet(this, _RedisDistributedBackend_subject, new pondsocket_common_1.Subject(), "f");
-        // Create Redis clients
+        __classPrivateFieldSet(this, _RedisDistributedBackend_heartbeatSubject, new pondsocket_common_1.Subject(), "f");
+        const reconnectStrategy = (retries) => {
+            const delay = Math.min(retries * 100, 5000);
+            return delay;
+        };
         const clientConfig = url
-            ? { url }
-            : { socket: { host,
-                    port },
+            ? { url,
+                socket: { reconnectStrategy } }
+            : {
+                socket: { host,
+                    port,
+                    reconnectStrategy },
                 password,
-                database };
+                database,
+            };
         __classPrivateFieldSet(this, _RedisDistributedBackend_publishClient, (0, redis_1.createClient)(clientConfig), "f");
         __classPrivateFieldSet(this, _RedisDistributedBackend_subscribeClient, __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").duplicate(), "f");
-        void __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_initialize).call(this);
+        __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_attachEventHandlers).call(this, __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f"), 'publish');
+        __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_attachEventHandlers).call(this, __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f"), 'subscribe');
     }
-    /**
-     * Gets the subject for subscribing to distributed messages
-     */
-    get subject() {
-        return __classPrivateFieldGet(this, _RedisDistributedBackend_subject, "f");
-    }
-    /**
-     * Subscribe to messages for a specific endpoint and channel
-     */
-    subscribe(endpointName, channelName, handler) {
-        return this.subject.subscribe((message) => {
-            if (message.endpointName === endpointName && message.channelName === channelName && message.nodeId !== __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f")) {
-                handler(message);
-            }
+    subscribeToChannel(endpointName, channelName, handler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_buildKey).call(this, endpointName, channelName);
+            const listener = (message) => {
+                try {
+                    const parsedMessage = JSON.parse(message);
+                    if (!__classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_isValidMessage).call(this, parsedMessage)) {
+                        return;
+                    }
+                    if (parsedMessage.nodeId !== __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f")) {
+                        handler(parsedMessage);
+                    }
+                }
+                catch (_) {
+                    void 0;
+                }
+            };
+            yield __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").subscribe(key, listener);
+            return () => {
+                __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").unsubscribe(key).catch(() => { });
+            };
         });
     }
-    /**
-     * Broadcasts a message to all nodes for a specific endpoint and channel
-     */
+    subscribeToHeartbeats(handler) {
+        return __classPrivateFieldGet(this, _RedisDistributedBackend_heartbeatSubject, "f").subscribe(handler);
+    }
     broadcast(endpointName, channelName, message) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!__classPrivateFieldGet(this, _RedisDistributedBackend_isConnected, "f")) {
                 throw new Error('Redis backend is not connected');
             }
             const key = __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_buildKey).call(this, endpointName, channelName);
-            const distributedMessage = Object.assign(Object.assign({}, message), { nodeId: __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f") });
+            const distributedMessage = Object.assign(Object.assign({}, message), { nodeId: __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f"), sourceNodeId: __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f") });
             const serializedMessage = JSON.stringify(distributedMessage);
             yield __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").publish(key, serializedMessage);
         });
     }
-    /**
-     * Cleanup and close all Redis connections
-     */
     cleanup() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.subject.close();
+            if (__classPrivateFieldGet(this, _RedisDistributedBackend_heartbeatTimer, "f")) {
+                clearInterval(__classPrivateFieldGet(this, _RedisDistributedBackend_heartbeatTimer, "f"));
+                __classPrivateFieldSet(this, _RedisDistributedBackend_heartbeatTimer, null, "f");
+            }
+            __classPrivateFieldGet(this, _RedisDistributedBackend_heartbeatSubject, "f").close();
             if (__classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").isOpen) {
                 yield __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").quit();
             }
@@ -95,29 +124,67 @@ class RedisDistributedBackend {
             __classPrivateFieldSet(this, _RedisDistributedBackend_isConnected, false, "f");
         });
     }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([
+                __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").connect(),
+                __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").connect(),
+            ]);
+            const heartbeatKey = __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_buildKey).call(this, '__heartbeat__', '__heartbeat__');
+            yield __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").subscribe(heartbeatKey, (message) => {
+                __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_handleHeartbeatMessage).call(this, message);
+            });
+            __classPrivateFieldSet(this, _RedisDistributedBackend_isConnected, true, "f");
+            __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_startHeartbeat).call(this);
+        });
+    }
 }
 exports.RedisDistributedBackend = RedisDistributedBackend;
-_RedisDistributedBackend_publishClient = new WeakMap(), _RedisDistributedBackend_subscribeClient = new WeakMap(), _RedisDistributedBackend_keyPrefix = new WeakMap(), _RedisDistributedBackend_subject = new WeakMap(), _RedisDistributedBackend_nodeId = new WeakMap(), _RedisDistributedBackend_isConnected = new WeakMap(), _RedisDistributedBackend_instances = new WeakSet(), _RedisDistributedBackend_initialize = function _RedisDistributedBackend_initialize() {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield Promise.all([
-            __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").connect(),
-            __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").connect(),
-        ]);
-        const pattern = `${__classPrivateFieldGet(this, _RedisDistributedBackend_keyPrefix, "f")}:*`;
-        yield __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").pSubscribe(pattern, (message) => {
-            __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_handleRedisMessage).call(this, message);
-        });
-        __classPrivateFieldSet(this, _RedisDistributedBackend_isConnected, true, "f");
+_RedisDistributedBackend_publishClient = new WeakMap(), _RedisDistributedBackend_subscribeClient = new WeakMap(), _RedisDistributedBackend_keyPrefix = new WeakMap(), _RedisDistributedBackend_heartbeatSubject = new WeakMap(), _RedisDistributedBackend_nodeId = new WeakMap(), _RedisDistributedBackend_heartbeatIntervalMs = new WeakMap(), _RedisDistributedBackend_heartbeatTimeoutMs = new WeakMap(), _RedisDistributedBackend_onError = new WeakMap(), _RedisDistributedBackend_isConnected = new WeakMap(), _RedisDistributedBackend_heartbeatTimer = new WeakMap(), _RedisDistributedBackend_instances = new WeakSet(), _RedisDistributedBackend_attachEventHandlers = function _RedisDistributedBackend_attachEventHandlers(client, label) {
+    client.on('error', (err) => {
+        __classPrivateFieldSet(this, _RedisDistributedBackend_isConnected, false, "f");
+        if (__classPrivateFieldGet(this, _RedisDistributedBackend_onError, "f")) {
+            __classPrivateFieldGet(this, _RedisDistributedBackend_onError, "f").call(this, new Error(`Redis ${label} client error: ${err.message}`));
+        }
+    });
+    client.on('ready', () => {
+        if (__classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").isReady && __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").isReady) {
+            __classPrivateFieldSet(this, _RedisDistributedBackend_isConnected, true, "f");
+        }
+    });
+    client.on('end', () => {
+        __classPrivateFieldSet(this, _RedisDistributedBackend_isConnected, false, "f");
+    });
+}, _RedisDistributedBackend_startHeartbeat = function _RedisDistributedBackend_startHeartbeat() {
+    __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_publishHeartbeat).call(this);
+    __classPrivateFieldSet(this, _RedisDistributedBackend_heartbeatTimer, setInterval(() => {
+        __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_publishHeartbeat).call(this);
+    }, __classPrivateFieldGet(this, _RedisDistributedBackend_heartbeatIntervalMs, "f")), "f");
+}, _RedisDistributedBackend_publishHeartbeat = function _RedisDistributedBackend_publishHeartbeat() {
+    if (!__classPrivateFieldGet(this, _RedisDistributedBackend_isConnected, "f")) {
+        return;
+    }
+    const heartbeatMessage = {
+        type: types_1.DistributedMessageType.NODE_HEARTBEAT,
+        endpointName: '__heartbeat__',
+        channelName: '__heartbeat__',
+        nodeId: __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f"),
+    };
+    const key = __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_buildKey).call(this, '__heartbeat__', '__heartbeat__');
+    __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").publish(key, JSON.stringify(heartbeatMessage)).catch((err) => {
+        if (__classPrivateFieldGet(this, _RedisDistributedBackend_onError, "f")) {
+            __classPrivateFieldGet(this, _RedisDistributedBackend_onError, "f").call(this, new Error(`Failed to publish heartbeat: ${err.message}`));
+        }
     });
-}, _RedisDistributedBackend_handleRedisMessage = function _RedisDistributedBackend_handleRedisMessage(message) {
+}, _RedisDistributedBackend_handleHeartbeatMessage = function _RedisDistributedBackend_handleHeartbeatMessage(message) {
     try {
         const parsedMessage = JSON.parse(message);
-        if (__classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_isValidMessage).call(this, parsedMessage)) {
-            this.subject.publish(parsedMessage);
+        if (parsedMessage.type === types_1.DistributedMessageType.NODE_HEARTBEAT && parsedMessage.nodeId !== __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f")) {
+            __classPrivateFieldGet(this, _RedisDistributedBackend_heartbeatSubject, "f").publish(parsedMessage.nodeId);
         }
     }
-    catch (_a) {
-        // Silently ignore invalid messages
+    catch (_) {
+        void 0;
     }
 }, _RedisDistributedBackend_isValidMessage = function _RedisDistributedBackend_isValidMessage(message) {
     return (typeof message === 'object' &&

package/abstracts/middleware.d.ts

@@ -0,0 +1,22 @@
+import { MiddlewareFunction, NextFunction } from './types';
+export declare class Middleware<Request, Response> {
+    #private;
+    constructor(second?: Middleware<Request, Response>);
+    /**
+     * @desc Returns the middleware stack length
+     */
+    get length(): number;
+    /**
+     * @desc Adds a middleware function to the middleware stack
+     * @param middleware - the middleware function to add
+     */
+    use(middleware: MiddlewareFunction<Request, Response> | Middleware<Request, Response>): this;
+    /**
+     * @desc Runs the middleware stack
+     * @param req - the request object
+     * @param res - the response object
+     * @param final - the final function to call
+     */
+    run(req: Request, res: Response, final: NextFunction): void;
+    runAsync(req: Request, res: Response, final: NextFunction): Promise<void>;
+}

package/abstracts/middleware.js

@@ -64,7 +64,14 @@ class Middleware {
             try {
                 const result = middleware(req, res, next);
                 if (result instanceof Promise) {
-                    result.catch(next);
+                    result.catch((error) => {
+                        try {
+                            final(__classPrivateFieldGet(this, _Middleware_instances, "m", _Middleware_handleError).call(this, error));
+                        }
+                        catch (_) {
+                            void 0;
+                        }
+                    });
                 }
             }
             catch (error) {

package/abstracts/types.d.ts

@@ -0,0 +1,64 @@
+import { IncomingHttpHeaders } from 'http';
+import { IncomingMessage } from 'node:http';
+import internal from 'node:stream';
+import { ChannelEvent, EventParams, JoinParams, PondAssigns, PondMessage, ServerActions, SystemSender, Unsubscribe, UserData } from '@eleven-am/pondsocket-common';
+import { WebSocket, WebSocketServer } from 'ws';
+import { ConnectionContext } from '../contexts/connectionContext';
+import { EventContext } from '../contexts/eventContext';
+import { JoinContext } from '../contexts/joinContext';
+import { OutgoingContext } from '../contexts/outgoingContext';
+import { EndpointEngine } from '../engines/endpointEngine';
+import { HttpError } from '../errors/httpError';
+import { Channel } from '../wrappers/channel';
+export type NextFunction<Error extends HttpError = HttpError> = (error?: Error) => void;
+export type MiddlewareFunction<Request, Response> = (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
+export interface SocketRequest {
+    id: string;
+    headers: IncomingHttpHeaders;
+    address: string;
+}
+export type ConnectionHandler<Path extends string> = (ctx: ConnectionContext<Path>, next: NextFunction) => void | Promise<void>;
+export type AuthorizationHandler<Path extends string> = (ctx: JoinContext<Path>, next: NextFunction) => void | Promise<void>;
+export type EventHandler<Path extends string> = (ctx: EventContext<Path>, next: NextFunction) => void | Promise<void>;
+export type OutgoingEventHandler<Event extends string> = (event: OutgoingContext<Event>, next: NextFunction) => PondMessage | Promise<PondMessage> | void | Promise<void>;
+export interface ConnectionParams {
+    head: Buffer;
+    socket: internal.Duplex;
+    request: IncomingMessage;
+    requestId: string;
+}
+export interface SocketCache {
+    clientId: string;
+    socket: WebSocket;
+    assigns: PondAssigns;
+    subscriptions: Set<Unsubscribe>;
+}
+export interface ConnectionResponseOptions {
+    engine: EndpointEngine;
+    params: ConnectionParams;
+    webSocketServer: WebSocketServer;
+}
+export interface JoinRequestOptions<Path extends string> {
+    clientId: string;
+    assigns: PondAssigns;
+    joinParams: JoinParams;
+    params: EventParams<Path>;
+}
+export interface RequestCache extends SocketCache {
+    channelName: string;
+    requestId: string;
+}
+export type InternalChannelEvent = ChannelEvent & {
+    recipients: string[];
+};
+export type ChannelSenders = SystemSender.CHANNEL | string;
+export type BroadcastEvent = Omit<InternalChannelEvent, 'action' | 'payload' | 'recipients'> & {
+    action: ServerActions.BROADCAST;
+    sender: ChannelSenders;
+    payload: PondMessage;
+};
+export interface LeaveEvent {
+    user: UserData;
+    channel: Channel;
+}
+export type LeaveCallback = (event: LeaveEvent) => void;

package/abstracts/types.js

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

package/contexts/baseContext.d.ts

@@ -0,0 +1,20 @@
+import { ChannelReceivers, EventParams, PondEvent, PondMessage, PondObject, UserAssigns, UserPresences } from '@eleven-am/pondsocket-common';
+import { ChannelEngine } from '../engines/channelEngine';
+import { Channel } from '../wrappers/channel';
+export declare abstract class BaseContext<Path extends string> {
+    #private;
+    constructor(engine: ChannelEngine, params: EventParams<Path>, event: string, payload: PondMessage, sender: string);
+    get event(): PondEvent<Path>;
+    get channelName(): string;
+    get channel(): Channel;
+    get presences(): UserPresences;
+    get assigns(): UserAssigns;
+    get user(): import("@eleven-am/pondsocket-common").UserData<PondObject, PondObject>;
+    broadcast(event: string, payload: PondMessage): this;
+    broadcastFrom(event: string, payload: PondMessage): this;
+    broadcastTo(event: string, payload: PondMessage, userIds: string | string[]): this;
+    protected abstract _sendMessageToRecipients(recipient: ChannelReceivers, event: string, payload: PondObject): void;
+    protected get engine(): ChannelEngine;
+    protected get sender(): string;
+    protected updateParams(params: EventParams<Path>): void;
+}

package/contexts/baseContext.js

@@ -13,6 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _BaseContext_engine, _BaseContext_params, _BaseContext_event, _BaseContext_sender, _BaseContext_payload;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseContext = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const channel_1 = require("../wrappers/channel");
 class BaseContext {
     constructor(engine, params, event, payload, sender) {
@@ -27,9 +28,6 @@ class BaseContext {
         __classPrivateFieldSet(this, _BaseContext_payload, payload, "f");
         __classPrivateFieldSet(this, _BaseContext_sender, sender, "f");
     }
-    /**
-     * The event information
-     */
     get event() {
         return {
             event: __classPrivateFieldGet(this, _BaseContext_event, "f"),
@@ -38,46 +36,40 @@ class BaseContext {
             payload: __classPrivateFieldGet(this, _BaseContext_payload, "f"),
         };
     }
-    /**
-     * The channel name
-     */
     get channelName() {
         return __classPrivateFieldGet(this, _BaseContext_engine, "f").name;
     }
-    /**
-     * The channel instance
-     */
     get channel() {
         return new channel_1.Channel(__classPrivateFieldGet(this, _BaseContext_engine, "f"));
     }
-    /**
-     * All current presences in the channel
-     */
     get presences() {
         return __classPrivateFieldGet(this, _BaseContext_engine, "f").getPresence();
     }
-    /**
-     * All current assigns in the channel
-     */
     get assigns() {
         return __classPrivateFieldGet(this, _BaseContext_engine, "f").getAssigns();
     }
-    /**
-     * The user who sent the request
-     */
     get user() {
         return this.channel.getUserData(__classPrivateFieldGet(this, _BaseContext_sender, "f"));
     }
-    /**
-     * Gets the channel engine instance
-     * @protected
-     */
+    broadcast(event, payload) {
+        this._sendMessageToRecipients(pondsocket_common_1.ChannelReceiver.ALL_USERS, event, payload);
+        return this;
+    }
+    broadcastFrom(event, payload) {
+        this._sendMessageToRecipients(pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, event, payload);
+        return this;
+    }
+    broadcastTo(event, payload, userIds) {
+        const ids = Array.isArray(userIds) ? userIds : [userIds];
+        this._sendMessageToRecipients(ids, event, payload);
+        return this;
+    }
     get engine() {
         return __classPrivateFieldGet(this, _BaseContext_engine, "f");
     }
-    /**
-     * Updates the event parameters.
-     */
+    get sender() {
+        return __classPrivateFieldGet(this, _BaseContext_sender, "f");
+    }
     updateParams(params) {
         __classPrivateFieldSet(this, _BaseContext_params, params, "f");
     }

package/contexts/connectionContext.d.ts

@@ -0,0 +1,66 @@
+import { IncomingHttpHeaders } from 'http';
+import { PondAssigns, PondMessage, IncomingConnection, Params, EventParams } from '@eleven-am/pondsocket-common';
+import { ConnectionResponseOptions } from '../abstracts/types';
+/**
+ * ConnectionContext combines IncomingConnection data with ConnectionResponse functionality.
+ */
+export declare class ConnectionContext<Path extends string> {
+    #private;
+    constructor(connectionData: IncomingConnection<Path>, { engine, params, webSocketServer }: ConnectionResponseOptions);
+    /**
+     * Whether the connection has been handled
+     */
+    get hasResponded(): boolean;
+    /**
+     * Connection details including headers, cookies, address, id, etc.
+     */
+    get connection(): IncomingConnection<Path>;
+    /**
+     * The request parameters
+     */
+    get requestId(): string;
+    /**
+     * The client ID
+     */
+    get clientId(): string;
+    /**
+     * The request headers
+     */
+    get headers(): IncomingHttpHeaders;
+    /**
+     * The request cookies
+     */
+    get cookies(): Record<string, string>;
+    /**
+     * The client address
+     */
+    get address(): string;
+    /**
+     * The event parameters
+     */
+    get event(): EventParams<Path>;
+    /**
+     * The query parameters
+     */
+    get query(): Record<string, string>;
+    /**
+     * The path parameters
+     */
+    get params(): Params<Path>;
+    /**
+     * Assigns data to the client
+     */
+    assign(assigns: PondAssigns): ConnectionContext<Path>;
+    /**
+     * Accepts the connection request
+     */
+    accept(): ConnectionContext<Path>;
+    /**
+     * Declines the connection request
+     */
+    decline(message?: string, errorCode?: number): ConnectionContext<Path>;
+    /**
+     * Sends a direct reply to the client
+     */
+    reply(event: string, payload: PondMessage): ConnectionContext<Path>;
+}

package/contexts/eventContext.d.ts

@@ -0,0 +1,15 @@
+import { ChannelReceivers, EventParams, PondAssigns, PondMessage, PondObject, PondPresence } from '@eleven-am/pondsocket-common';
+import { BaseContext } from './baseContext';
+import { BroadcastEvent } from '../abstracts/types';
+import { ChannelEngine } from '../engines/channelEngine';
+export declare class EventContext<Path extends string> extends BaseContext<Path> {
+    #private;
+    constructor(event: BroadcastEvent, params: EventParams<Path>, engine: ChannelEngine);
+    assign(assigns: PondAssigns): EventContext<Path>;
+    reply(event: string, payload: PondMessage): this;
+    trackPresence(presence: PondPresence, userId?: string): EventContext<Path>;
+    updatePresence(presence: PondPresence, userId?: string): EventContext<Path>;
+    evictUser(reason: string, userId?: string): EventContext<Path>;
+    removePresence(userId?: string): EventContext<Path>;
+    protected _sendMessageToRecipients(recipient: ChannelReceivers, event: string, payload: PondObject): void;
+}