@eleven-am/pondsocket 0.1.216 → 0.1.218

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;
@@ -39,10 +42,10 @@ export interface ConnectionResponseOptions {
     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 {
@@ -59,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,7 +115,10 @@ 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 = {

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,8 +44,11 @@ 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);

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.d.ts

@@ -17,6 +17,8 @@ export declare class ChannelEngine {
     upsertPresence(userId: string, presence: PondPresence): void;
     updateAssigns(userId: string, assigns: PondMessage): void;
     kickUser(userId: string, reason: string): void;
+    requestUserRemoval(userId: string): void;
+    getUserAcrossNodes(userId: string, timeoutMs?: number): Promise<UserData | null>;
     getAssigns(): UserAssigns;
     getPresence(): UserPresences;
     destroy(reason?: string): void;

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_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;
+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_pendingUserGets, _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_handleRemoteUserRemove, _ChannelEngine_handleRemoteUserGetRequest, _ChannelEngine_handleRemoteUserGetResponse, _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");
@@ -59,6 +59,7 @@ class ChannelEngine {
         _ChannelEngine_heartbeatSubscription.set(this, null);
         _ChannelEngine_nodeLastSeen.set(this, new Map());
         _ChannelEngine_nodeUsers.set(this, new Map());
+        _ChannelEngine_pendingUserGets.set(this, new Map());
         _ChannelEngine_staleNodeTimer.set(this, null);
         _ChannelEngine_name.set(this, void 0);
         _ChannelEngine_closed.set(this, false);
@@ -222,6 +223,38 @@ class ChannelEngine {
         });
         this.removeUser(userId, true);
     }
+    requestUserRemoval(userId) {
+        __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+            type: types_1.DistributedMessageType.USER_REMOVE,
+            endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+            channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+            userId,
+        });
+    }
+    getUserAcrossNodes(userId, timeoutMs = 5000) {
+        if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            return Promise.resolve(null);
+        }
+        const requestId = (0, pondsocket_common_1.uuid)();
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").delete(requestId);
+                resolve(null);
+            }, timeoutMs);
+            __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").set(requestId, {
+                resolve,
+                timer,
+            });
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.USER_GET_REQUEST,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                requestId,
+                fromNode: __classPrivateFieldGet(this, _ChannelEngine_nodeId, "f"),
+            });
+        });
+    }
     getAssigns() {
         return mapToObject(__classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f"));
     }
@@ -304,6 +337,8 @@ class ChannelEngine {
             clearInterval(__classPrivateFieldGet(this, _ChannelEngine_staleNodeTimer, "f"));
             __classPrivateFieldSet(this, _ChannelEngine_staleNodeTimer, null, "f");
         }
+        __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").forEach((pending) => clearTimeout(pending.timer));
+        __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").clear();
         __classPrivateFieldGet(this, _ChannelEngine_nodeLastSeen, "f").clear();
         __classPrivateFieldGet(this, _ChannelEngine_nodeUsers, "f").clear();
         __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").close();
@@ -311,7 +346,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_closed = new WeakMap(), _ChannelEngine_distributedReady = 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_pendingUserGets = 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);
@@ -421,6 +456,15 @@ _ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(
         case types_1.DistributedMessageType.EVICT_USER:
             __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteEvictUser).call(this, message);
             break;
+        case types_1.DistributedMessageType.USER_REMOVE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteUserRemove).call(this, message);
+            break;
+        case types_1.DistributedMessageType.USER_GET_REQUEST:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteUserGetRequest).call(this, message);
+            break;
+        case types_1.DistributedMessageType.USER_GET_RESPONSE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteUserGetResponse).call(this, message);
+            break;
         case types_1.DistributedMessageType.NODE_HEARTBEAT:
             break;
         default:
@@ -545,6 +589,40 @@ _ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(
         unsubscribe();
         __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").delete(message.userId);
     }
+}, _ChannelEngine_handleRemoteUserRemove = function _ChannelEngine_handleRemoteUserRemove(message) {
+    if (__classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").has(message.userId)) {
+        this.removeUser(message.userId);
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").delete(message.userId);
+    __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_safeRemovePresence).call(this, message.userId);
+    __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_untrackNodeUser).call(this, message.sourceNodeId, message.userId);
+}, _ChannelEngine_handleRemoteUserGetRequest = function _ChannelEngine_handleRemoteUserGetRequest(message) {
+    var _a;
+    if (!__classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").has(message.userId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+        type: types_1.DistributedMessageType.USER_GET_RESPONSE,
+        endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+        channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+        userId: message.userId,
+        requestId: message.requestId,
+        assigns: __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").get(message.userId) || {},
+        presence: ((_a = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) === null || _a === void 0 ? void 0 : _a.getPresence(message.userId)) || {},
+    });
+}, _ChannelEngine_handleRemoteUserGetResponse = function _ChannelEngine_handleRemoteUserGetResponse(message) {
+    const pending = __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").get(message.requestId);
+    if (!pending) {
+        return;
+    }
+    clearTimeout(pending.timer);
+    __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").delete(message.requestId);
+    pending.resolve({
+        id: message.userId,
+        assigns: message.assigns || {},
+        presence: message.presence || {},
+    });
 }, _ChannelEngine_setupHeartbeatTracking = function _ChannelEngine_setupHeartbeatTracking() {
     if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
         return;

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();
         });

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);
         });
     }
     /**
@@ -68,12 +68,13 @@ class LobbyEngine {
             if (!params || context.isBlocked()) {
                 return next();
             }
-            context.updateParams(params);
-            const payload = yield handler(context, next);
+            const typedContext = context;
+            typedContext.updateParams(params);
+            const payload = yield handler(typedContext, next);
             if (payload === undefined || payload === null) {
                 return;
             }
-            context.transform(payload);
+            typedContext.transform(payload);
             return next();
         }));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.216",
+  "version": "0.1.218",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -43,7 +43,9 @@
     "url": "git+https://github.com/Eleven-am/pondSocket.git"
   },
   "dependencies": {
-    "@eleven-am/pondsocket-common": "^0.0.38",
+    "@eleven-am/pondsocket-common": "^0.0.40",
+    "@types/node": "^25.3.3",
+    "@types/ws": "^8.18.1",
     "redis": "^5.12.1",
     "ws": "^8.20.1"
   },

package/server/server.js

@@ -93,7 +93,7 @@ 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);
     }

package/types.d.ts

@@ -100,20 +100,19 @@ export interface EvictUser extends DistributedMessage {
 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;
+    requestId: string;
+    fromNode: string;
 }
 export interface UserGetResponse extends DistributedMessage {
     type: DistributedMessageType.USER_GET_RESPONSE;
-    lookupRequestId: string;
     userId: string;
-    found: boolean;
-    assigns?: PondAssigns;
-    presence?: PondPresence;
+    requestId: string;
+    assigns: PondAssigns;
+    presence: PondPresence;
 }
 export interface NodeHeartbeat extends DistributedMessage {
     type: DistributedMessageType.NODE_HEARTBEAT;

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,17 @@ 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;
+    /**
+     * Resolves a user's data from any node in the distributed cluster
+     */
+    getUserAcrossNodes(userId: string, timeoutMs?: number): Promise<UserData<PresenceOf<Schema>, AssignsOf<Schema>> | null>;
+    /**
+     * Requests removal of a user across all nodes in the distributed cluster
+     */
+    requestUserRemoval(userId: string): this;
 }

package/wrappers/channel.js

@@ -101,6 +101,19 @@ class Channel {
         __classPrivateFieldGet(this, _Channel_engine, "f").updateAssigns(userId, assigns);
         return this;
     }
+    /**
+     * Resolves a user's data from any node in the distributed cluster
+     */
+    getUserAcrossNodes(userId, timeoutMs) {
+        return __classPrivateFieldGet(this, _Channel_engine, "f").getUserAcrossNodes(userId, timeoutMs);
+    }
+    /**
+     * Requests removal of a user across all nodes in the distributed cluster
+     */
+    requestUserRemoval(userId) {
+        __classPrivateFieldGet(this, _Channel_engine, "f").requestUserRemoval(userId);
+        return this;
+    }
 }
 exports.Channel = Channel;
 _Channel_engine = new WeakMap();

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>;
 }