@eleven-am/pondsocket 0.1.215 → 0.1.217

package/abstracts/distributor.js

@@ -19,12 +19,18 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     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 _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;
+var _RedisDistributedBackend_instances, _RedisDistributedBackend_publishClient, _RedisDistributedBackend_subscribeClient, _RedisDistributedBackend_keyPrefix, _RedisDistributedBackend_namespace, _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, _RedisDistributedBackend_normalizeTopicPart;
 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 DISTRIBUTED_PROTOCOL = 'pondsocket.distributed';
+const DISTRIBUTED_VERSION = 1;
+function distributedId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36)
+        .slice(2)}`;
+}
 class RedisDistributedBackend {
     get nodeId() {
         return __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f");
@@ -37,6 +43,7 @@ class RedisDistributedBackend {
         _RedisDistributedBackend_publishClient.set(this, void 0);
         _RedisDistributedBackend_subscribeClient.set(this, void 0);
         _RedisDistributedBackend_keyPrefix.set(this, void 0);
+        _RedisDistributedBackend_namespace.set(this, void 0);
         _RedisDistributedBackend_heartbeatSubject.set(this, void 0);
         _RedisDistributedBackend_nodeId.set(this, void 0);
         _RedisDistributedBackend_heartbeatIntervalMs.set(this, void 0);
@@ -44,8 +51,9 @@ class RedisDistributedBackend {
         _RedisDistributedBackend_onError.set(this, void 0);
         _RedisDistributedBackend_isConnected.set(this, false);
         _RedisDistributedBackend_heartbeatTimer.set(this, null);
-        const { host = 'localhost', port = 6379, password, database = 0, url, keyPrefix = 'pondsocket', heartbeatIntervalMs = 30000, heartbeatTimeoutMs = 90000, onError = null, } = options;
+        const { host = 'localhost', port = 6379, password, database = 0, url, keyPrefix = 'pondsocket', namespace = 'default', heartbeatIntervalMs = 30000, heartbeatTimeoutMs = 90000, onError = null, } = options;
         __classPrivateFieldSet(this, _RedisDistributedBackend_keyPrefix, keyPrefix, "f");
+        __classPrivateFieldSet(this, _RedisDistributedBackend_namespace, namespace, "f");
         __classPrivateFieldSet(this, _RedisDistributedBackend_heartbeatIntervalMs, heartbeatIntervalMs, "f");
         __classPrivateFieldSet(this, _RedisDistributedBackend_heartbeatTimeoutMs, heartbeatTimeoutMs, "f");
         __classPrivateFieldSet(this, _RedisDistributedBackend_onError, onError, "f");
@@ -80,7 +88,7 @@ class RedisDistributedBackend {
                     if (!__classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_isValidMessage).call(this, parsedMessage)) {
                         return;
                     }
-                    if (parsedMessage.nodeId !== __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f")) {
+                    if (parsedMessage.sourceNodeId !== __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f")) {
                         handler(parsedMessage);
                     }
                 }
@@ -99,11 +107,13 @@ class RedisDistributedBackend {
     }
     broadcast(endpointName, channelName, message) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             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"), sourceNodeId: __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f") });
+            const normalizedEndpointName = __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_normalizeTopicPart).call(this, endpointName);
+            const distributedMessage = Object.assign(Object.assign({}, message), { protocol: DISTRIBUTED_PROTOCOL, version: DISTRIBUTED_VERSION, messageId: (_a = message.messageId) !== null && _a !== void 0 ? _a : distributedId(), timestamp: (_b = message.timestamp) !== null && _b !== void 0 ? _b : Date.now(), sourceNodeId: __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f"), endpointName: normalizedEndpointName });
             const serializedMessage = JSON.stringify(distributedMessage);
             yield __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").publish(key, serializedMessage);
         });
@@ -140,7 +150,7 @@ class RedisDistributedBackend {
     }
 }
 exports.RedisDistributedBackend = RedisDistributedBackend;
-_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) {
+_RedisDistributedBackend_publishClient = new WeakMap(), _RedisDistributedBackend_subscribeClient = new WeakMap(), _RedisDistributedBackend_keyPrefix = new WeakMap(), _RedisDistributedBackend_namespace = 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")) {
@@ -165,9 +175,14 @@ _RedisDistributedBackend_publishClient = new WeakMap(), _RedisDistributedBackend
         return;
     }
     const heartbeatMessage = {
+        protocol: DISTRIBUTED_PROTOCOL,
+        version: DISTRIBUTED_VERSION,
         type: types_1.DistributedMessageType.NODE_HEARTBEAT,
+        messageId: distributedId(),
         endpointName: '__heartbeat__',
         channelName: '__heartbeat__',
+        sourceNodeId: __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f"),
+        timestamp: Date.now(),
         nodeId: __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f"),
     };
     const key = __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_buildKey).call(this, '__heartbeat__', '__heartbeat__');
@@ -179,8 +194,8 @@ _RedisDistributedBackend_publishClient = new WeakMap(), _RedisDistributedBackend
 }, _RedisDistributedBackend_handleHeartbeatMessage = function _RedisDistributedBackend_handleHeartbeatMessage(message) {
     try {
         const parsedMessage = JSON.parse(message);
-        if (parsedMessage.type === types_1.DistributedMessageType.NODE_HEARTBEAT && parsedMessage.nodeId !== __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f")) {
-            __classPrivateFieldGet(this, _RedisDistributedBackend_heartbeatSubject, "f").publish(parsedMessage.nodeId);
+        if (__classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_isValidMessage).call(this, parsedMessage) && parsedMessage.type === types_1.DistributedMessageType.NODE_HEARTBEAT && parsedMessage.sourceNodeId && parsedMessage.sourceNodeId !== __classPrivateFieldGet(this, _RedisDistributedBackend_nodeId, "f")) {
+            __classPrivateFieldGet(this, _RedisDistributedBackend_heartbeatSubject, "f").publish(parsedMessage.sourceNodeId);
         }
     }
     catch (_) {
@@ -188,10 +203,20 @@ _RedisDistributedBackend_publishClient = new WeakMap(), _RedisDistributedBackend
     }
 }, _RedisDistributedBackend_isValidMessage = function _RedisDistributedBackend_isValidMessage(message) {
     return (typeof message === 'object' &&
+        message.protocol === DISTRIBUTED_PROTOCOL &&
+        message.version === DISTRIBUTED_VERSION &&
         typeof message.type === 'string' &&
         Object.values(types_1.DistributedMessageType).includes(message.type) &&
+        typeof message.messageId === 'string' &&
         typeof message.endpointName === 'string' &&
-        typeof message.channelName === 'string');
+        typeof message.channelName === 'string' &&
+        typeof message.sourceNodeId === 'string' &&
+        typeof message.timestamp === 'number');
 }, _RedisDistributedBackend_buildKey = function _RedisDistributedBackend_buildKey(endpointName, channelName) {
-    return `${__classPrivateFieldGet(this, _RedisDistributedBackend_keyPrefix, "f")}:${endpointName}:${channelName}`;
+    if (endpointName === '__heartbeat__' && channelName === '__heartbeat__') {
+        return `${__classPrivateFieldGet(this, _RedisDistributedBackend_keyPrefix, "f")}:v1:${__classPrivateFieldGet(this, _RedisDistributedBackend_namespace, "f")}:__heartbeat__`;
+    }
+    return `${__classPrivateFieldGet(this, _RedisDistributedBackend_keyPrefix, "f")}:v1:${__classPrivateFieldGet(this, _RedisDistributedBackend_namespace, "f")}:${__classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_normalizeTopicPart).call(this, endpointName)}:${channelName}`;
+}, _RedisDistributedBackend_normalizeTopicPart = function _RedisDistributedBackend_normalizeTopicPart(value) {
+    return value.replace(/^\/+/, '');
 };

package/abstracts/types.d.ts

@@ -1,7 +1,7 @@
 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 { ChannelEvent, AnyPondSchema, AssignsOf, EventParams, EventsOf, JoinParamsOf, PondAssigns, PondEventMap, PondMessage, PondPresence, ServerActions, SystemSender, Unsubscribe, UserData } from '@eleven-am/pondsocket-common';
 import { WebSocket, WebSocketServer } from 'ws';
 import { ConnectionContext } from '../contexts/connectionContext';
 import { EventContext } from '../contexts/eventContext';
@@ -17,10 +17,13 @@ export interface SocketRequest {
     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 type EventPayload<EventMap extends PondEventMap, Event extends keyof EventMap> = EventMap[Event] extends [PondMessage, PondMessage] ? EventMap[Event][0] : EventMap[Event];
+export type EventResponse<EventMap extends PondEventMap, Event extends keyof EventMap> = EventMap[Event] extends [PondMessage, PondMessage] ? EventMap[Event][1] : PondMessage;
+export type EventKey<Schema extends AnyPondSchema> = Extract<keyof EventsOf<Schema>, string>;
+export type ConnectionHandler<Path extends string> = (ctx: ConnectionContext<Path>, next: NextFunction) => unknown | Promise<unknown>;
+export type AuthorizationHandler<Path extends string, Schema extends AnyPondSchema = AnyPondSchema> = (ctx: JoinContext<Path, Schema>, next: NextFunction) => unknown | Promise<unknown>;
+export type EventHandler<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, Event extends EventKey<Schema> = EventKey<Schema>> = (ctx: EventContext<Path, Schema, Event>, next: NextFunction) => unknown | Promise<unknown>;
+export type OutgoingEventHandler<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, Event extends EventKey<Schema> = EventKey<Schema>> = (event: OutgoingContext<Path, Schema, Event>, next: NextFunction) => EventPayload<EventsOf<Schema>, Event> | Promise<EventPayload<EventsOf<Schema>, Event>> | void | Promise<void>;
 export interface ConnectionParams {
     head: Buffer;
     socket: internal.Duplex;
@@ -32,16 +35,17 @@ export interface SocketCache {
     socket: WebSocket;
     assigns: PondAssigns;
     subscriptions: Set<Unsubscribe>;
+    channelSubscriptions?: Map<string, Unsubscribe>;
 }
 export interface ConnectionResponseOptions {
     engine: EndpointEngine;
     params: ConnectionParams;
     webSocketServer: WebSocketServer;
 }
-export interface JoinRequestOptions<Path extends string> {
+export interface JoinRequestOptions<Path extends string, Schema extends AnyPondSchema = AnyPondSchema> {
     clientId: string;
-    assigns: PondAssigns;
-    joinParams: JoinParams;
+    assigns: AssignsOf<Schema>;
+    joinParams: JoinParamsOf<Schema>;
     params: EventParams<Path>;
 }
 export interface RequestCache extends SocketCache {
@@ -58,7 +62,7 @@ export type BroadcastEvent = Omit<InternalChannelEvent, 'action' | 'payload' | '
     payload: PondMessage;
 };
 export interface LeaveEvent {
-    user: UserData;
+    user: UserData<PondPresence, PondAssigns>;
     channel: Channel;
 }
 export type LeaveCallback = (event: LeaveEvent) => void;

package/contexts/baseContext.d.ts

@@ -1,18 +1,23 @@
-import { ChannelReceivers, EventParams, PondEvent, PondMessage, PondObject, UserAssigns, UserPresences } from '@eleven-am/pondsocket-common';
+import { ChannelReceivers, AnyPondSchema, AssignsOf, EventParams, EventPayload, EventsOf, PondEvent, PondMessage, PondObject, PresenceOf, 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> {
+export declare abstract class BaseContext<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, EventName extends Extract<keyof EventsOf<Schema>, string> = Extract<keyof EventsOf<Schema>, string>, Payload extends PondMessage = EventPayload<EventsOf<Schema>, EventName>> {
     #private;
-    constructor(engine: ChannelEngine, params: EventParams<Path>, event: string, payload: PondMessage, sender: string);
-    get event(): PondEvent<Path>;
+    protected constructor(engine: ChannelEngine, params: EventParams<Path>, event: string, payload: Payload, sender: string);
+    get event(): PondEvent<Path> & {
+        event: EventName;
+        payload: Payload;
+    };
+    get query(): EventParams<Path>['query'];
+    get params(): EventParams<Path>['params'];
     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;
+    get channel(): Channel<Schema>;
+    get presences(): UserPresences<PresenceOf<Schema>>;
+    get assigns(): UserAssigns<AssignsOf<Schema>>;
+    get user(): import("@eleven-am/pondsocket-common").UserData<PresenceOf<Schema>, AssignsOf<Schema>> | null;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>, userIds: string | string[]): this;
     protected abstract _sendMessageToRecipients(recipient: ChannelReceivers, event: string, payload: PondObject): void;
     protected get engine(): ChannelEngine;
     protected get sender(): string;

package/contexts/baseContext.js

@@ -36,6 +36,12 @@ class BaseContext {
             payload: __classPrivateFieldGet(this, _BaseContext_payload, "f"),
         };
     }
+    get query() {
+        return __classPrivateFieldGet(this, _BaseContext_params, "f").query;
+    }
+    get params() {
+        return __classPrivateFieldGet(this, _BaseContext_params, "f").params;
+    }
     get channelName() {
         return __classPrivateFieldGet(this, _BaseContext_engine, "f").name;
     }

package/contexts/connectionContext.d.ts

@@ -54,7 +54,7 @@ export declare class ConnectionContext<Path extends string> {
     /**
      * Accepts the connection request
      */
-    accept(): ConnectionContext<Path>;
+    accept(assigns?: PondAssigns): ConnectionContext<Path>;
     /**
      * Declines the connection request
      */

package/contexts/connectionContext.js

@@ -115,12 +115,16 @@ class ConnectionContext {
     /**
      * Accepts the connection request
      */
-    accept() {
+    accept(assigns) {
+        if (assigns) {
+            this.assign(assigns);
+        }
         __classPrivateFieldGet(this, _ConnectionContext_instances, "m", _ConnectionContext_performChecks).call(this);
         __classPrivateFieldGet(this, _ConnectionContext_webSocketServer, "f").handleUpgrade(__classPrivateFieldGet(this, _ConnectionContext_params, "f").request, __classPrivateFieldGet(this, _ConnectionContext_params, "f").socket, __classPrivateFieldGet(this, _ConnectionContext_params, "f").head, (ws) => {
             const cache = {
                 clientId: __classPrivateFieldGet(this, _ConnectionContext_clientId, "f"),
                 subscriptions: new Set(),
+                channelSubscriptions: new Map(),
                 assigns: __classPrivateFieldGet(this, _ConnectionContext_assigns, "f"),
                 socket: ws,
             };

package/contexts/eventContext.d.ts

@@ -1,15 +1,16 @@
-import { ChannelReceivers, EventParams, PondAssigns, PondMessage, PondObject, PondPresence } from '@eleven-am/pondsocket-common';
+import { ChannelReceivers, AnyPondSchema, AssignsOf, EventParams, EventPayload, EventsOf, PondObject, PresenceOf } 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> {
+export declare class EventContext<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, EventName extends Extract<keyof EventsOf<Schema>, string> = Extract<keyof EventsOf<Schema>, string>> extends BaseContext<Path, Schema, EventName, EventPayload<EventsOf<Schema>, EventName>> {
     #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>;
+    get payload(): EventPayload<EventsOf<Schema>, EventName>;
+    assign(assigns: Partial<AssignsOf<Schema>>): EventContext<Path, Schema, EventName>;
+    reply<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    trackPresence(presence: PresenceOf<Schema>, userId?: string): EventContext<Path, Schema, EventName>;
+    updatePresence(presence: Partial<PresenceOf<Schema>>, userId?: string): EventContext<Path, Schema, EventName>;
+    evictUser(reason: string, userId?: string): EventContext<Path, Schema, EventName>;
+    removePresence(userId?: string): EventContext<Path, Schema, EventName>;
     protected _sendMessageToRecipients(recipient: ChannelReceivers, event: string, payload: PondObject): void;
 }

package/contexts/eventContext.js

@@ -23,6 +23,9 @@ class EventContext extends baseContext_1.BaseContext {
         __classPrivateFieldSet(this, _EventContext_event, event, "f");
         __classPrivateFieldSet(this, _EventContext_requestId, event.requestId, "f");
     }
+    get payload() {
+        return __classPrivateFieldGet(this, _EventContext_event, "f").payload;
+    }
     assign(assigns) {
         this.channel.updateAssigns(__classPrivateFieldGet(this, _EventContext_event, "f").sender, assigns);
         return this;

package/contexts/joinContext.d.ts

@@ -1,17 +1,17 @@
-import { ChannelReceivers, JoinParams, PondAssigns, PondMessage, PondObject, PondPresence, UserData } from '@eleven-am/pondsocket-common';
+import { ChannelReceivers, AnyPondSchema, AssignsOf, EventsOf, JoinParamsOf, PondMessage, PondObject, PresenceOf, UserData } from '@eleven-am/pondsocket-common';
 import { BaseContext } from './baseContext';
 import { JoinRequestOptions, RequestCache } from '../abstracts/types';
 import { ChannelEngine } from '../engines/channelEngine';
-export declare class JoinContext<Path extends string> extends BaseContext<Path> {
+export declare class JoinContext<Path extends string, Schema extends AnyPondSchema = AnyPondSchema> extends BaseContext<Path, Schema, Extract<keyof EventsOf<Schema>, string>, JoinParamsOf<Schema>> {
     #private;
-    constructor(options: JoinRequestOptions<Path>, engine: ChannelEngine, user: RequestCache);
-    get user(): UserData;
-    get joinParams(): JoinParams;
+    constructor(options: JoinRequestOptions<Path, Schema>, engine: ChannelEngine, user: RequestCache);
+    get user(): UserData<PresenceOf<Schema>, AssignsOf<Schema>>;
+    get joinParams(): JoinParamsOf<Schema>;
     get hasResponded(): boolean;
-    accept(): JoinContext<Path>;
-    decline(message?: string, errorCode?: number): JoinContext<Path>;
-    assign(assigns: PondAssigns): JoinContext<Path>;
-    reply(event: string, payload: PondMessage): JoinContext<Path>;
-    trackPresence(presence: PondPresence): JoinContext<Path>;
+    accept(assigns?: Partial<AssignsOf<Schema>>): JoinContext<Path, Schema>;
+    decline(message?: string, errorCode?: number): JoinContext<Path, Schema>;
+    assign(assigns: Partial<AssignsOf<Schema>>): JoinContext<Path, Schema>;
+    reply(event: string, payload: PondMessage): JoinContext<Path, Schema>;
+    trackPresence(presence: PresenceOf<Schema>): JoinContext<Path, Schema>;
     protected _sendMessageToRecipients(recipient: ChannelReceivers, event: string, payload: PondObject): void;
 }

package/contexts/joinContext.js

@@ -44,11 +44,22 @@ class JoinContext extends baseContext_1.BaseContext {
     get hasResponded() {
         return __classPrivateFieldGet(this, _JoinContext_executed, "f");
     }
-    accept() {
+    accept(assigns) {
+        var _a;
+        if (assigns) {
+            this.assign(assigns);
+        }
         __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_performChecks).call(this);
         const onMessage = this.engine.parent.parent.sendMessage.bind(this.engine.parent.parent, __classPrivateFieldGet(this, _JoinContext_user, "f").socket);
         const subscription = this.engine.addUser(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, __classPrivateFieldGet(this, _JoinContext_newAssigns, "f"), onMessage);
-        __classPrivateFieldGet(this, _JoinContext_user, "f").subscriptions.add(subscription);
+        const wrappedSubscription = () => {
+            var _a;
+            subscription();
+            __classPrivateFieldGet(this, _JoinContext_user, "f").subscriptions.delete(wrappedSubscription);
+            (_a = __classPrivateFieldGet(this, _JoinContext_user, "f").channelSubscriptions) === null || _a === void 0 ? void 0 : _a.delete(this.engine.name);
+        };
+        __classPrivateFieldGet(this, _JoinContext_user, "f").subscriptions.add(wrappedSubscription);
+        (_a = __classPrivateFieldGet(this, _JoinContext_user, "f").channelSubscriptions) === null || _a === void 0 ? void 0 : _a.set(this.engine.name, wrappedSubscription);
         __classPrivateFieldSet(this, _JoinContext_accepted, true, "f");
         return this;
     }

package/contexts/outgoingContext.d.ts

@@ -1,10 +1,10 @@
-import { ChannelReceivers, Event, EventParams, PondMessage, PondObject } from '@eleven-am/pondsocket-common';
+import { ChannelReceivers, AnyPondSchema, Event, EventParams, EventPayload, EventsOf, PondObject } from '@eleven-am/pondsocket-common';
 import { BaseContext } from './baseContext';
 import { ChannelEngine } from '../engines/channelEngine';
-export declare class OutgoingContext<Path extends string> extends BaseContext<Path> {
+export declare class OutgoingContext<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, EventName extends Extract<keyof EventsOf<Schema>, string> = Extract<keyof EventsOf<Schema>, string>> extends BaseContext<Path, Schema, EventName, EventPayload<EventsOf<Schema>, EventName>> {
     #private;
     constructor(event: Event, params: EventParams<Path>, engine: ChannelEngine, userid: string);
-    get payload(): PondMessage;
+    get payload(): EventPayload<EventsOf<Schema>, EventName>;
     /**
      * Blocks the outgoing context, preventing further processing of the event.
      */
@@ -18,7 +18,7 @@ export declare class OutgoingContext<Path extends string> extends BaseContext<Pa
      * Transforms the outgoing context with a new payload.
      * @param payload - The new payload to set for the context.
      */
-    transform(payload: PondMessage): this;
+    transform(payload: EventPayload<EventsOf<Schema>, EventName>): this;
     /**
      * Updates the parameters of the outgoing context.
      * @param params - The new parameters to set for the context.

package/engines/channelEngine.js

@@ -30,7 +30,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var _ChannelEngine_instances, _ChannelEngine_endpointId, _ChannelEngine_backend, _ChannelEngine_nodeId, _ChannelEngine_presenceEngine, _ChannelEngine_assignsCache, _ChannelEngine_userSubscriptions, _ChannelEngine_publisher, _ChannelEngine_distributedSubscription, _ChannelEngine_heartbeatSubscription, _ChannelEngine_nodeLastSeen, _ChannelEngine_nodeUsers, _ChannelEngine_staleNodeTimer, _ChannelEngine_name, _ChannelEngine_safeRemovePresence, _ChannelEngine_buildSubscriber, _ChannelEngine_getOrCreatePresenceEngine, _ChannelEngine_getUsersFromRecipients, _ChannelEngine_setupDistributedSubscription, _ChannelEngine_handleDistributedMessage, _ChannelEngine_requestChannelState, _ChannelEngine_handleStateRequest, _ChannelEngine_handleStateResponse, _ChannelEngine_handleRemoteUserJoined, _ChannelEngine_handleRemoteUserLeft, _ChannelEngine_handleRemoteMessage, _ChannelEngine_handleRemotePresenceUpdate, _ChannelEngine_handleRemotePresenceRemoved, _ChannelEngine_handleRemoteAssignsUpdate, _ChannelEngine_handleRemoteEvictUser, _ChannelEngine_setupHeartbeatTracking, _ChannelEngine_cleanupStaleNodes, _ChannelEngine_trackNodeUser, _ChannelEngine_untrackNodeUser, _ChannelEngine_broadcastToNodes;
+var _ChannelEngine_instances, _ChannelEngine_endpointId, _ChannelEngine_backend, _ChannelEngine_nodeId, _ChannelEngine_presenceEngine, _ChannelEngine_assignsCache, _ChannelEngine_userSubscriptions, _ChannelEngine_publisher, _ChannelEngine_distributedSubscription, _ChannelEngine_heartbeatSubscription, _ChannelEngine_nodeLastSeen, _ChannelEngine_nodeUsers, _ChannelEngine_staleNodeTimer, _ChannelEngine_name, _ChannelEngine_closed, _ChannelEngine_distributedReady, _ChannelEngine_safeRemovePresence, _ChannelEngine_buildSubscriber, _ChannelEngine_getOrCreatePresenceEngine, _ChannelEngine_getUsersFromRecipients, _ChannelEngine_setupDistributedSubscription, _ChannelEngine_afterDistributedReady, _ChannelEngine_handleDistributedMessage, _ChannelEngine_requestChannelState, _ChannelEngine_handleStateRequest, _ChannelEngine_handleStateResponse, _ChannelEngine_handleRemoteUserJoined, _ChannelEngine_handleRemoteUserLeft, _ChannelEngine_handleRemoteMessage, _ChannelEngine_handleRemotePresenceUpdate, _ChannelEngine_handleRemotePresenceRemoved, _ChannelEngine_handleRemoteAssignsUpdate, _ChannelEngine_handleRemoteEvictUser, _ChannelEngine_setupHeartbeatTracking, _ChannelEngine_cleanupStaleNodes, _ChannelEngine_trackNodeUser, _ChannelEngine_untrackNodeUser, _ChannelEngine_broadcastToNodes;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -61,12 +61,14 @@ class ChannelEngine {
         _ChannelEngine_nodeUsers.set(this, new Map());
         _ChannelEngine_staleNodeTimer.set(this, null);
         _ChannelEngine_name.set(this, void 0);
+        _ChannelEngine_closed.set(this, false);
+        _ChannelEngine_distributedReady.set(this, null);
         __classPrivateFieldSet(this, _ChannelEngine_name, name, "f");
         __classPrivateFieldSet(this, _ChannelEngine_backend, backend, "f");
         __classPrivateFieldSet(this, _ChannelEngine_nodeId, (0, pondsocket_common_1.uuid)(), "f");
         __classPrivateFieldSet(this, _ChannelEngine_endpointId, parent.parent.path, "f");
         if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
-            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_setupDistributedSubscription).call(this).catch(() => { });
+            __classPrivateFieldSet(this, _ChannelEngine_distributedReady, __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_setupDistributedSubscription).call(this).catch(() => { }), "f");
             __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_setupHeartbeatTracking).call(this);
         }
     }
@@ -92,7 +94,7 @@ class ChannelEngine {
         __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(userId, assigns);
         __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_buildSubscriber).call(this, userId, onMessage);
         if (isFirstUser && __classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
-            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_requestChannelState).call(this);
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_afterDistributedReady).call(this, () => __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_requestChannelState).call(this));
         }
         __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
             type: types_1.DistributedMessageType.USER_JOINED,
@@ -282,6 +284,7 @@ class ChannelEngine {
         };
     }
     close() {
+        __classPrivateFieldSet(this, _ChannelEngine_closed, true, "f");
         __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").forEach((unsubscribe) => unsubscribe());
         __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").clear();
         __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").clear();
@@ -308,7 +311,7 @@ class ChannelEngine {
     }
 }
 exports.ChannelEngine = ChannelEngine;
-_ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(), _ChannelEngine_nodeId = new WeakMap(), _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new WeakMap(), _ChannelEngine_userSubscriptions = new WeakMap(), _ChannelEngine_publisher = new WeakMap(), _ChannelEngine_distributedSubscription = new WeakMap(), _ChannelEngine_heartbeatSubscription = new WeakMap(), _ChannelEngine_nodeLastSeen = new WeakMap(), _ChannelEngine_nodeUsers = new WeakMap(), _ChannelEngine_staleNodeTimer = new WeakMap(), _ChannelEngine_name = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_safeRemovePresence = function _ChannelEngine_safeRemovePresence(userId) {
+_ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(), _ChannelEngine_nodeId = new WeakMap(), _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new WeakMap(), _ChannelEngine_userSubscriptions = new WeakMap(), _ChannelEngine_publisher = new WeakMap(), _ChannelEngine_distributedSubscription = new WeakMap(), _ChannelEngine_heartbeatSubscription = new WeakMap(), _ChannelEngine_nodeLastSeen = new WeakMap(), _ChannelEngine_nodeUsers = new WeakMap(), _ChannelEngine_staleNodeTimer = new WeakMap(), _ChannelEngine_name = new WeakMap(), _ChannelEngine_closed = new WeakMap(), _ChannelEngine_distributedReady = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_safeRemovePresence = function _ChannelEngine_safeRemovePresence(userId) {
     if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
         try {
             __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(userId);
@@ -370,10 +373,25 @@ _ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(
         if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
             return;
         }
-        __classPrivateFieldSet(this, _ChannelEngine_distributedSubscription, yield __classPrivateFieldGet(this, _ChannelEngine_backend, "f").subscribeToChannel(__classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"), __classPrivateFieldGet(this, _ChannelEngine_name, "f"), (message) => {
+        const unsubscribe = yield __classPrivateFieldGet(this, _ChannelEngine_backend, "f").subscribeToChannel(__classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"), __classPrivateFieldGet(this, _ChannelEngine_name, "f"), (message) => {
             __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleDistributedMessage).call(this, message);
-        }), "f");
+        });
+        if (__classPrivateFieldGet(this, _ChannelEngine_closed, "f")) {
+            unsubscribe();
+            return;
+        }
+        __classPrivateFieldSet(this, _ChannelEngine_distributedSubscription, unsubscribe, "f");
     });
+}, _ChannelEngine_afterDistributedReady = function _ChannelEngine_afterDistributedReady(callback) {
+    if (!__classPrivateFieldGet(this, _ChannelEngine_distributedReady, "f")) {
+        callback();
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_distributedReady, "f").then(() => {
+        if (!__classPrivateFieldGet(this, _ChannelEngine_closed, "f")) {
+            return callback();
+        }
+    }).catch(() => { });
 }, _ChannelEngine_handleDistributedMessage = function _ChannelEngine_handleDistributedMessage(message) {
     switch (message.type) {
         case types_1.DistributedMessageType.STATE_REQUEST:
@@ -494,7 +512,17 @@ _ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(
 }, _ChannelEngine_handleRemotePresenceRemoved = function _ChannelEngine_handleRemotePresenceRemoved(message) {
     __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_safeRemovePresence).call(this, message.userId);
 }, _ChannelEngine_handleRemoteAssignsUpdate = function _ChannelEngine_handleRemoteAssignsUpdate(message) {
-    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(message.userId, message.assigns);
+    const current = __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").get(message.userId);
+    if (!current) {
+        return;
+    }
+    if (message.assigns) {
+        __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(message.userId, message.assigns);
+        return;
+    }
+    if (message.key) {
+        __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(message.userId, Object.assign(Object.assign({}, current), { [message.key]: message.value }));
+    }
 }, _ChannelEngine_handleRemoteEvictUser = function _ChannelEngine_handleRemoteEvictUser(message) {
     if (__classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").has(message.userId)) {
         const kickedOutEvent = {
@@ -576,6 +604,9 @@ _ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(
             return;
         }
         try {
+            if (__classPrivateFieldGet(this, _ChannelEngine_closed, "f")) {
+                return;
+            }
             yield __classPrivateFieldGet(this, _ChannelEngine_backend, "f").broadcast(__classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"), __classPrivateFieldGet(this, _ChannelEngine_name, "f"), message);
         }
         catch (_) {

package/engines/endpointEngine.d.ts

@@ -1,4 +1,4 @@
-import { ChannelEvent, PondPath } from '@eleven-am/pondsocket-common';
+import { ChannelEvent, AnyPondSchema, PondPath } from '@eleven-am/pondsocket-common';
 import { WebSocket } from 'ws';
 import { AuthorizationHandler, SocketCache } from '../abstracts/types';
 import { IDistributedBackend } from '../types';
@@ -10,7 +10,7 @@ export declare class EndpointEngine {
     /**
      * Creates a new channel on a specified path
      */
-    createChannel<Path extends string>(path: PondPath<Path>, handler: AuthorizationHandler<Path>): PondChannel;
+    createChannel<Path extends string, Schema extends AnyPondSchema = AnyPondSchema>(path: PondPath<Path>, handler: AuthorizationHandler<Path, Schema>): PondChannel<Schema>;
     /**
      * Gets all connected clients
      */

package/engines/endpointEngine.js

@@ -52,7 +52,7 @@ class EndpointEngine {
                 };
                 const channel = lobbyEngine.getOrCreateChannel(user.channelName);
                 const context = new joinContext_1.JoinContext(options, channel, user);
-                return handler(context, next);
+                return Promise.resolve(handler(context, next)).then(() => undefined);
             }
             next();
         });
@@ -115,11 +115,13 @@ class EndpointEngine {
 }
 exports.EndpointEngine = EndpointEngine;
 _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_backend = new WeakMap(), _EndpointEngine_middleware = new WeakMap(), _EndpointEngine_lobbyEngines = new WeakMap(), _EndpointEngine_maxMessageSize = new WeakMap(), _EndpointEngine_instances = new WeakSet(), _EndpointEngine_handleSocketClose = function _EndpointEngine_handleSocketClose(cache) {
+    var _a;
     try {
         __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").delete(cache.clientId);
         cache.subscriptions.forEach((unsubscribe) => unsubscribe());
+        (_a = cache.channelSubscriptions) === null || _a === void 0 ? void 0 : _a.clear();
     }
-    catch (_a) {
+    catch (_b) {
         void 0;
     }
 }, _EndpointEngine_handleMessage = function _EndpointEngine_handleMessage(cache, message) {
@@ -143,6 +145,12 @@ _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_backend = new WeakMap()
         throw error;
     });
 }, _EndpointEngine_leaveChannel = function _EndpointEngine_leaveChannel(channel, socket) {
+    var _a;
+    const subscription = (_a = socket.channelSubscriptions) === null || _a === void 0 ? void 0 : _a.get(channel);
+    if (subscription) {
+        subscription();
+        return;
+    }
     const engine = __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_retrieveChannel).call(this, channel);
     engine.removeUser(socket.clientId);
 }, _EndpointEngine_retrieveChannel = function _EndpointEngine_retrieveChannel(channel) {

package/engines/lobbyEngine.d.ts

@@ -1,4 +1,4 @@
-import { Event, PondPath } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, Event, EventsOf, PondPath } from '@eleven-am/pondsocket-common';
 import { ChannelEngine } from './channelEngine';
 import { EndpointEngine } from './endpointEngine';
 import { Middleware } from '../abstracts/middleware';
@@ -20,11 +20,11 @@ export declare class LobbyEngine {
     /**
      * Attaches a handler for a specific event pattern
      */
-    onEvent<Event extends string>(event: PondPath<Event>, handler: EventHandler<Event>): void;
+    onEvent<Schema extends AnyPondSchema, Path extends Extract<keyof EventsOf<Schema>, string>>(event: PondPath<Path>, handler: EventHandler<Path, Schema, Path>): void;
     /**
      * Attaches a handler for outgoing events
      */
-    handleOutgoingEvent<Event extends string>(event: PondPath<Event>, handler: OutgoingEventHandler<Event>): void;
+    handleOutgoingEvent<Schema extends AnyPondSchema, Path extends Extract<keyof EventsOf<Schema>, string>>(event: PondPath<Path>, handler: OutgoingEventHandler<Path, Schema, Path>): void;
     /**
      * Processes an outgoing event, applying middleware and returning a new event
      * @param event - The channel event to process

package/engines/lobbyEngine.js

@@ -56,7 +56,7 @@ class LobbyEngine {
                 return next();
             }
             const context = new eventContext_1.EventContext(requestEvent, params, channel);
-            return handler(context, next);
+            return Promise.resolve(handler(context, next)).then(() => undefined);
         });
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.215",
+  "version": "0.1.217",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -43,21 +43,23 @@
     "url": "git+https://github.com/Eleven-am/pondSocket.git"
   },
   "dependencies": {
-    "@eleven-am/pondsocket-common": "^0.0.37",
-    "redis": "^5.11.0",
-    "ws": "^8.19.0"
+    "@eleven-am/pondsocket-common": "^0.0.39",
+    "@types/node": "^25.3.3",
+    "@types/ws": "^8.18.1",
+    "redis": "^5.12.1",
+    "ws": "^8.20.1"
   },
   "devDependencies": {
     "@eslint/compat": "^1.4.0",
     "@eslint/eslintrc": "^3.3.4",
-    "@eslint/js": "^9.38.0",
+    "@eslint/js": "^9.39.4",
     "@stylistic/eslint-plugin-ts": "^4.4.1",
     "@types/jest": "^30.0.0",
     "@types/node": "^25.3.3",
     "@types/ws": "^8.18.1",
-    "@typescript-eslint/eslint-plugin": "^8.56.1",
-    "@typescript-eslint/parser": "^8.56.1",
-    "eslint": "^9.38.0",
+    "@typescript-eslint/eslint-plugin": "^8.59.4",
+    "@typescript-eslint/parser": "^8.59.4",
+    "eslint": "^9.39.4",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-node": "^0.3.9",
     "eslint-plugin-file-progress": "^3.0.2",
@@ -65,11 +67,11 @@
     "eslint-plugin-prettier": "^5.5.5",
     "globals": "^16.4.0",
     "jest": "^30.2.0",
-    "prettier": "^3.8.1",
+    "prettier": "^3.8.3",
     "source-map-support": "^0.5.21",
     "supertest": "^7.2.2",
-    "ts-jest": "^29.4.6",
-    "ts-loader": "^9.5.4",
+    "ts-jest": "^29.4.11",
+    "ts-loader": "^9.5.7",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.9.3"

package/server/server.js

@@ -10,7 +10,7 @@ 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_server, _PondSocket_exclusiveServer, _PondSocket_socketServer, _PondSocket_backend, _PondSocket_middleware, _PondSocket_maxMessageSize, _PondSocket_heartbeatMs, _PondSocket_heartbeatTimer, _PondSocket_handleUpgrade, _PondSocket_manageHeartbeat, _PondSocket_init, _PondSocket_getCookies;
+var _PondSocket_instances, _PondSocket_server, _PondSocket_exclusiveServer, _PondSocket_socketServer, _PondSocket_backend, _PondSocket_middleware, _PondSocket_maxMessageSize, _PondSocket_heartbeatMs, _PondSocket_heartbeatTimer, _PondSocket_backendReady, _PondSocket_handleUpgrade, _PondSocket_manageHeartbeat, _PondSocket_init, _PondSocket_getCookies;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocket = void 0;
 const http_1 = require("http");
@@ -32,6 +32,7 @@ class PondSocket {
         _PondSocket_maxMessageSize.set(this, void 0);
         _PondSocket_heartbeatMs.set(this, void 0);
         _PondSocket_heartbeatTimer.set(this, null);
+        _PondSocket_backendReady.set(this, null);
         __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");
@@ -51,6 +52,7 @@ class PondSocket {
      * Close the server
      */
     close(callback, timeout = 5000) {
+        var _a, _b;
         if (__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f")) {
             clearInterval(__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f"));
             __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, null, "f");
@@ -71,6 +73,7 @@ class PondSocket {
         __classPrivateFieldGet(this, _PondSocket_socketServer, "f").close(() => {
             clearTimeout(forceClose);
         });
+        __classPrivateFieldSet(this, _PondSocket_backendReady, (_b = (_a = __classPrivateFieldGet(this, _PondSocket_backendReady, "f")) === null || _a === void 0 ? void 0 : _a.catch(() => { }).then(() => { var _a; return (_a = __classPrivateFieldGet(this, _PondSocket_backend, "f")) === null || _a === void 0 ? void 0 : _a.cleanup(); }).catch(() => { })) !== null && _b !== void 0 ? _b : null, "f");
         return __classPrivateFieldGet(this, _PondSocket_server, "f").close(callback);
     }
     /**
@@ -90,13 +93,13 @@ class PondSocket {
                 webSocketServer: __classPrivateFieldGet(this, _PondSocket_socketServer, "f"),
             };
             const context = new connectionContext_1.ConnectionContext(request, newParams);
-            return handler(context, next);
+            return Promise.resolve(handler(context, next)).then(() => undefined);
         });
         return new endpoint_1.Endpoint(endpoint);
     }
 }
 exports.PondSocket = PondSocket;
-_PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_backend = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_maxMessageSize = new WeakMap(), _PondSocket_heartbeatMs = new WeakMap(), _PondSocket_heartbeatTimer = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_handleUpgrade = function _PondSocket_handleUpgrade(req, socket, head) {
+_PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_backend = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_maxMessageSize = new WeakMap(), _PondSocket_heartbeatMs = new WeakMap(), _PondSocket_heartbeatTimer = new WeakMap(), _PondSocket_backendReady = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_handleUpgrade = function _PondSocket_handleUpgrade(req, socket, head) {
     const clientId = (0, pondsocket_common_1.uuid)();
     const request = {
         id: clientId,
@@ -137,7 +140,11 @@ _PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(),
         });
     }, __classPrivateFieldGet(this, _PondSocket_heartbeatMs, "f"));
 }, _PondSocket_init = function _PondSocket_init() {
+    var _a, _b;
     __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_manageHeartbeat).call(this), "f");
+    __classPrivateFieldSet(this, _PondSocket_backendReady, (_b = (_a = __classPrivateFieldGet(this, _PondSocket_backend, "f")) === null || _a === void 0 ? void 0 : _a.initialize().catch((error) => {
+        __classPrivateFieldGet(this, _PondSocket_server, "f").emit('error', error);
+    })) !== null && _b !== void 0 ? _b : null, "f");
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('error', (error) => {
         if (__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f")) {
             clearInterval(__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f"));

package/types.d.ts

@@ -8,6 +8,7 @@ export interface RedisDistributedBackendOptions {
     database?: number;
     url?: string;
     keyPrefix?: string;
+    namespace?: string;
     heartbeatIntervalMs?: number;
     heartbeatTimeoutMs?: number;
     onError?: (error: Error) => void;
@@ -30,10 +31,16 @@ export declare enum DistributedMessageType {
     PRESENCE_REMOVED = "PRESENCE_REMOVED",
     ASSIGNS_UPDATE = "ASSIGNS_UPDATE",
     EVICT_USER = "EVICT_USER",
+    USER_REMOVE = "USER_REMOVE",
+    USER_GET_REQUEST = "USER_GET_REQUEST",
+    USER_GET_RESPONSE = "USER_GET_RESPONSE",
     NODE_HEARTBEAT = "NODE_HEARTBEAT"
 }
 export interface DistributedMessage {
+    protocol?: 'pondsocket.distributed';
+    version?: 1;
     type: DistributedMessageType;
+    messageId?: string;
     endpointName: string;
     channelName: string;
     timestamp?: number;
@@ -81,19 +88,38 @@ export interface PresenceRemoved extends DistributedMessage {
 export interface AssignsUpdate extends DistributedMessage {
     type: DistributedMessageType.ASSIGNS_UPDATE;
     userId: string;
-    assigns: PondAssigns;
+    assigns?: PondAssigns;
+    key?: string;
+    value?: unknown;
 }
 export interface EvictUser extends DistributedMessage {
     type: DistributedMessageType.EVICT_USER;
     userId: string;
     reason: string;
-    fromNode?: string;
+}
+export interface UserRemove extends DistributedMessage {
+    type: DistributedMessageType.USER_REMOVE;
+    userId: string;
+    reason: string;
+}
+export interface UserGetRequest extends DistributedMessage {
+    type: DistributedMessageType.USER_GET_REQUEST;
+    userId: string;
+    lookupRequestId: string;
+}
+export interface UserGetResponse extends DistributedMessage {
+    type: DistributedMessageType.USER_GET_RESPONSE;
+    lookupRequestId: string;
+    userId: string;
+    found: boolean;
+    assigns?: PondAssigns;
+    presence?: PondPresence;
 }
 export interface NodeHeartbeat extends DistributedMessage {
     type: DistributedMessageType.NODE_HEARTBEAT;
     nodeId: string;
 }
-export type DistributedChannelMessage = StateRequest | StateResponse | UserJoined | UserLeft | UserMessage | PresenceUpdate | PresenceRemoved | AssignsUpdate | EvictUser | NodeHeartbeat;
+export type DistributedChannelMessage = StateRequest | StateResponse | UserJoined | UserLeft | UserMessage | PresenceUpdate | PresenceRemoved | AssignsUpdate | EvictUser | UserRemove | UserGetRequest | UserGetResponse | NodeHeartbeat;
 export interface IDistributedBackend {
     readonly nodeId: string;
     readonly heartbeatTimeoutMs: number;

package/types.js

@@ -12,5 +12,8 @@ var DistributedMessageType;
     DistributedMessageType["PRESENCE_REMOVED"] = "PRESENCE_REMOVED";
     DistributedMessageType["ASSIGNS_UPDATE"] = "ASSIGNS_UPDATE";
     DistributedMessageType["EVICT_USER"] = "EVICT_USER";
+    DistributedMessageType["USER_REMOVE"] = "USER_REMOVE";
+    DistributedMessageType["USER_GET_REQUEST"] = "USER_GET_REQUEST";
+    DistributedMessageType["USER_GET_RESPONSE"] = "USER_GET_RESPONSE";
     DistributedMessageType["NODE_HEARTBEAT"] = "NODE_HEARTBEAT";
 })(DistributedMessageType || (exports.DistributedMessageType = DistributedMessageType = {}));

package/wrappers/channel.d.ts

@@ -1,32 +1,32 @@
-import { PondMessage, PondAssigns, PondPresence } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, AssignsOf, EventsOf, EventPayload, PresenceOf, UserData, UserAssigns, UserPresences } from '@eleven-am/pondsocket-common';
 import { ChannelEngine } from '../engines/channelEngine';
-export declare class Channel {
+export declare class Channel<Schema extends AnyPondSchema = AnyPondSchema> {
     #private;
     constructor(engine: ChannelEngine);
     /**
      * Gets a user's data
      */
-    getUserData(userId: string): import("@eleven-am/pondsocket-common").UserData<import("@eleven-am/pondsocket-common").PondObject, import("@eleven-am/pondsocket-common").PondObject>;
+    getUserData(userId: string): UserData<PresenceOf<Schema>, AssignsOf<Schema>> | null;
     /**
      * Gets all presence data
      */
-    getPresences(): import("@eleven-am/pondsocket-common").UserPresences;
+    getPresences(): UserPresences<PresenceOf<Schema>>;
     /**
      * Gets all assigns data
      */
-    getAssigns(): import("@eleven-am/pondsocket-common").UserAssigns;
+    getAssigns(): UserAssigns<AssignsOf<Schema>>;
     /**
      * Broadcasts a message to all users
      */
-    broadcast(event: string, payload: PondMessage): this;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
     /**
      * Broadcasts a message from a specific user to all others
      */
-    broadcastFrom(userId: string, event: string, payload: PondMessage): this;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
     /**
      * Broadcasts a message to specific users
      */
-    broadcastTo(userIds: string | string[], event: string, payload: PondMessage): this;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
     /**
      * Kicks a user from the channel
      */
@@ -34,11 +34,11 @@ export declare class Channel {
     /**
      * Tracks a user's presence
      */
-    trackPresence(userId: string, presence: PondPresence): this;
+    trackPresence(userId: string, presence: PresenceOf<Schema>): this;
     /**
      * Updates a user's presence
      */
-    updatePresence(userId: string, presence: PondPresence): this;
+    updatePresence(userId: string, presence: Partial<PresenceOf<Schema>>): this;
     /**
      * Removes a user's presence
      */
@@ -46,9 +46,9 @@ export declare class Channel {
     /**
      * Adds or updates a user's presence
      */
-    upsertPresence(userId: string, presence: PondPresence): this;
+    upsertPresence(userId: string, presence: PresenceOf<Schema>): this;
     /**
      * Updates a user's assigns
      */
-    updateAssigns(userId: string, assigns: PondAssigns): this;
+    updateAssigns(userId: string, assigns: Partial<AssignsOf<Schema>>): this;
 }

package/wrappers/endpoint.d.ts

@@ -1,10 +1,10 @@
-import { PondPath } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, PondPath } from '@eleven-am/pondsocket-common';
 import { AuthorizationHandler } from '../abstracts/types';
 import { EndpointEngine } from '../engines/endpointEngine';
 export declare class Endpoint {
     #private;
     constructor(engine: EndpointEngine);
-    createChannel<Path extends string>(path: PondPath<Path>, handler: AuthorizationHandler<Path>): import("./pondChannel").PondChannel;
+    createChannel<Path extends string, Schema extends AnyPondSchema = AnyPondSchema>(path: PondPath<Path>, handler: AuthorizationHandler<Path, Schema>): import("./pondChannel").PondChannel<Schema>;
     closeConnection(clientIds: string | string[]): void;
     getClients(): import("ws").WebSocket[];
 }

package/wrappers/pondChannel.d.ts

@@ -1,15 +1,15 @@
-import { PondMessage, PondPath } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, EventPayload, EventsOf, PondPath } from '@eleven-am/pondsocket-common';
 import { Channel } from './channel';
 import { EventHandler, LeaveCallback, OutgoingEventHandler } from '../abstracts/types';
 import { LobbyEngine } from '../engines/lobbyEngine';
-export declare class PondChannel {
+export declare class PondChannel<Schema extends AnyPondSchema = AnyPondSchema> {
     #private;
     constructor(lobby: LobbyEngine);
-    onEvent<Event extends string>(event: PondPath<Event>, handler: EventHandler<Event>): PondChannel;
-    onLeave(callback: LeaveCallback): PondChannel;
-    handleOutgoingEvent<Event extends string>(event: PondPath<Event>, handler: OutgoingEventHandler<Event>): this;
-    getChannel(channelName: string): Channel | null;
-    broadcast(channelName: string, event: string, payload: PondMessage): PondChannel;
-    broadcastFrom(channelName: string, userId: string, event: string, payload: PondMessage): PondChannel;
-    broadcastTo(channelName: string, userIds: string | string[], event: string, payload: PondMessage): PondChannel;
+    onEvent<Event extends Extract<keyof EventsOf<Schema>, string>>(event: PondPath<Event>, handler: EventHandler<Event, Schema, Event>): PondChannel<Schema>;
+    onLeave(callback: LeaveCallback): PondChannel<Schema>;
+    handleOutgoingEvent<Event extends Extract<keyof EventsOf<Schema>, string>>(event: PondPath<Event>, handler: OutgoingEventHandler<Event, Schema, Event>): this;
+    getChannel(channelName: string): Channel<Schema> | null;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
 }