@socket-mesh/server 18.1.4 → 19.0.0

package/dist/broker/broker-events.d.ts

@@ -2,6 +2,10 @@ export type BrokerEvent<T> = ErrorEvent | PublishEvent<T> | ReadyEvent | Subscri
 export interface ErrorEvent {
     error: Error;
 }
+export interface PublishEvent<T> {
+    channel: string;
+    data: T;
+}
 export interface ReadyEvent {
 }
 export interface SubscribeEvent {
@@ -10,7 +14,3 @@ export interface SubscribeEvent {
 export interface UnsubscribeEvent {
     channel: string;
 }
-export interface PublishEvent<T> {
-    channel: string;
-    data: T;
-}

package/dist/broker/broker.d.ts

@@ -1,10 +1,11 @@
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
-import { DemuxedConsumableStream, StreamEvent } from "@socket-mesh/stream-demux";
-import { BrokerEvent, ErrorEvent, PublishEvent, ReadyEvent, SubscribeEvent, UnsubscribeEvent } from "./broker-events.js";
-import { ChannelMap } from "@socket-mesh/channels";
-import { Exchange } from "./exchange.js";
-import { ExchangeClient } from "./exchange-client.js";
+import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
+import { ChannelMap } from '@socket-mesh/channels';
+import { DemuxedConsumableStream, StreamEvent } from '@socket-mesh/stream-demux';
+import { BrokerEvent, ErrorEvent, PublishEvent, ReadyEvent, SubscribeEvent, UnsubscribeEvent } from './broker-events.js';
+import { ExchangeClient } from './exchange-client.js';
+import { Exchange } from './exchange.js';
 export declare abstract class Broker<T extends ChannelMap> extends AsyncStreamEmitter<BrokerEvent<T[keyof T]>> {
+    abstract readonly exchange: Exchange<T>;
     isReady: boolean;
     constructor();
     emit(event: 'error', data: ErrorEvent): void;
@@ -12,17 +13,16 @@ export declare abstract class Broker<T extends ChannelMap> extends AsyncStreamEm
     emit(event: 'ready', data: ReadyEvent): void;
     emit(event: 'subscribe', data: SubscribeEvent): void;
     emit(event: 'unsubscribe', data: UnsubscribeEvent): void;
+    abstract invokePublish<U extends keyof T & string>(channelName: U, data: T[U], suppressEvent?: boolean): Promise<void>;
+    abstract isSubscribed(channelName: string): boolean;
     listen(): DemuxedConsumableStream<StreamEvent<BrokerEvent<T[keyof T]>>>;
     listen(event: 'ready'): DemuxedConsumableStream<ReadyEvent>;
     listen(event: 'publish'): DemuxedConsumableStream<PublishEvent<T[keyof T]>>;
     listen(event: 'error'): DemuxedConsumableStream<ErrorEvent>;
     listen(event: 'subscribe'): DemuxedConsumableStream<SubscribeEvent>;
     listen(event: 'unsubscribe'): DemuxedConsumableStream<UnsubscribeEvent>;
-    abstract readonly exchange: Exchange<T>;
     abstract subscribe(socket: ExchangeClient, channelName: string): Promise<void>;
     abstract subscriptions(): string[];
-    abstract isSubscribed(channelName: string): boolean;
-    abstract unsubscribe(socket: ExchangeClient, channelName: string): Promise<void>;
     abstract transmitPublish<U extends keyof T & string>(channelName: U, data: T[U], suppressEvent?: boolean): Promise<void>;
-    abstract invokePublish<U extends keyof T & string>(channelName: U, data: T[U], suppressEvent?: boolean): Promise<void>;
+    abstract unsubscribe(socket: ExchangeClient, channelName: string): Promise<void>;
 }

package/dist/broker/broker.js

@@ -1,5 +1,6 @@
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
+import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
 export class Broker extends AsyncStreamEmitter {
+    isReady;
     constructor() {
         super();
         this.isReady = false;

package/dist/broker/exchange-client.d.ts

@@ -1,4 +1,4 @@
-import { PublishOptions } from "@socket-mesh/channels";
+import { PublishOptions } from '@socket-mesh/channels';
 export interface ExchangeClient {
     id: string;
     transmit(event: '#publish', options: PublishOptions): Promise<void>;

package/dist/broker/exchange.d.ts

@@ -1,4 +1,9 @@
-import { ChannelMap, Channels } from "@socket-mesh/channels";
+import { ChannelMap, Channels, ChannelsOptions } from '@socket-mesh/channels';
+interface ExchangeOptions extends ChannelsOptions {
+    id: string;
+}
 export declare abstract class Exchange<T extends ChannelMap> extends Channels<T> {
     id: string;
+    constructor(options: ExchangeOptions);
 }
+export {};

package/dist/broker/exchange.js

@@ -1,3 +1,8 @@
-import { Channels } from "@socket-mesh/channels";
+import { Channels } from '@socket-mesh/channels';
 export class Exchange extends Channels {
+    id;
+    constructor(options) {
+        super(options);
+        this.id = options.id;
+    }
 }

package/dist/broker/index.d.ts

@@ -0,0 +1,5 @@
+export * from './broker-events.js';
+export * from './broker.js';
+export * from './exchange-client.js';
+export * from './simple-broker.js';
+export * from './simple-exchange.js';

package/dist/broker/index.js

@@ -0,0 +1,5 @@
+export * from './broker-events.js';
+export * from './broker.js';
+export * from './exchange-client.js';
+export * from './simple-broker.js';
+export * from './simple-exchange.js';

package/dist/broker/simple-broker.d.ts

@@ -1,16 +1,16 @@
-import { Broker } from "./broker.js";
-import { ChannelMap } from "@socket-mesh/channels";
-import { SimpleExchange } from "./simple-exchange.js";
-import { ExchangeClient } from "./exchange-client.js";
+import { ChannelMap } from '@socket-mesh/channels';
+import { Broker } from './broker.js';
+import { ExchangeClient } from './exchange-client.js';
+import { SimpleExchange } from './simple-exchange.js';
 export declare class SimpleBroker<T extends ChannelMap> extends Broker<T> {
-    readonly exchange: SimpleExchange<T>;
     private readonly _clientSubscribers;
     private readonly _clientSubscribersCounter;
+    readonly exchange: SimpleExchange<T>;
     constructor();
+    invokePublish<U extends keyof T & string>(channelName: U, data: T[U], suppressEvent?: boolean): Promise<void>;
+    isSubscribed(channelName: string): boolean;
     subscribe(client: ExchangeClient, channelName: string): Promise<void>;
-    unsubscribe(client: ExchangeClient, channelName: string): Promise<void>;
     subscriptions(): string[];
-    isSubscribed(channelName: string): boolean;
-    invokePublish<U extends keyof T & string>(channelName: U, data: T[U], suppressEvent?: boolean): Promise<void>;
     transmitPublish<U extends keyof T & string>(channelName: U, data: T[U], suppressEvent?: boolean): Promise<void>;
+    unsubscribe(client: ExchangeClient, channelName: string): Promise<void>;
 }

package/dist/broker/simple-broker.js

@@ -1,12 +1,23 @@
-import { Broker } from "./broker.js";
-import { SimpleExchange } from "./simple-exchange.js";
+import { Broker } from './broker.js';
+import { SimpleExchange } from './simple-exchange.js';
 export class SimpleBroker extends Broker {
+    _clientSubscribers;
+    _clientSubscribersCounter;
+    exchange;
     constructor() {
         super();
         this.exchange = new SimpleExchange(this);
         this._clientSubscribers = {};
         this._clientSubscribersCounter = {};
     }
+    // In this implementation of the broker engine, both invokePublish and transmitPublish
+    // methods are the same. In alternative implementations, they could be different.
+    invokePublish(channelName, data, suppressEvent) {
+        return this.transmitPublish(channelName, data, suppressEvent);
+    }
+    isSubscribed(channelName) {
+        return !!this._clientSubscribers[channelName];
+    }
     async subscribe(client, channelName) {
         if (!this._clientSubscribers[channelName]) {
             this._clientSubscribers[channelName] = {};
@@ -18,30 +29,9 @@ export class SimpleBroker extends Broker {
         }
         this._clientSubscribers[channelName][client.id] = client;
     }
-    async unsubscribe(client, channelName) {
-        if (this._clientSubscribers[channelName]) {
-            if (this._clientSubscribers[channelName][client.id]) {
-                this._clientSubscribersCounter[channelName]--;
-                delete this._clientSubscribers[channelName][client.id];
-                if (this._clientSubscribersCounter[channelName] <= 0) {
-                    delete this._clientSubscribers[channelName];
-                    delete this._clientSubscribersCounter[channelName];
-                    this.emit('unsubscribe', { channel: channelName });
-                }
-            }
-        }
-    }
     subscriptions() {
         return Object.keys(this._clientSubscribers);
     }
-    isSubscribed(channelName) {
-        return !!this._clientSubscribers[channelName];
-    }
-    // In this implementation of the broker engine, both invokePublish and transmitPublish
-    // methods are the same. In alternative implementations, they could be different.
-    invokePublish(channelName, data, suppressEvent) {
-        return this.transmitPublish(channelName, data, suppressEvent);
-    }
     async transmitPublish(channelName, data, suppressEvent) {
         const packet = {
             channel: channelName,
@@ -62,4 +52,17 @@ export class SimpleBroker extends Broker {
             this.emit('publish', packet);
         }
     }
+    async unsubscribe(client, channelName) {
+        if (this._clientSubscribers[channelName]) {
+            if (this._clientSubscribers[channelName][client.id]) {
+                this._clientSubscribersCounter[channelName]--;
+                delete this._clientSubscribers[channelName][client.id];
+                if (this._clientSubscribersCounter[channelName] <= 0) {
+                    delete this._clientSubscribers[channelName];
+                    delete this._clientSubscribersCounter[channelName];
+                    this.emit('unsubscribe', { channel: channelName });
+                }
+            }
+        }
+    }
 }

package/dist/broker/simple-exchange.d.ts

@@ -1,13 +1,12 @@
-import { ChannelDetails, ChannelMap, ChannelsOptions, PublishOptions } from "@socket-mesh/channels";
-import { Broker } from "./broker.js";
-import { Exchange } from "./exchange.js";
+import { ChannelDetails, ChannelMap, ChannelsOptions, PublishOptions } from '@socket-mesh/channels';
+import { Broker } from './broker.js';
+import { Exchange } from './exchange.js';
 export declare class SimpleExchange<T extends ChannelMap> extends Exchange<T> {
-    readonly id: string;
     private readonly _broker;
     constructor(broker: Broker<T>, options?: ChannelsOptions);
-    protected trySubscribe(channel: ChannelDetails): Promise<void>;
-    protected tryUnsubscribe(channel: ChannelDetails): Promise<void>;
+    invokePublish<U extends keyof T & string>(channelName: U, data: T[U]): Promise<void>;
     transmit(event: '#publish', packet: PublishOptions): Promise<void>;
     transmitPublish<U extends keyof T & string>(channelName: U, data: T[U]): Promise<void>;
-    invokePublish<U extends keyof T & string>(channelName: U, data: T[U]): Promise<void>;
+    protected trySubscribe(channel: ChannelDetails): Promise<void>;
+    protected tryUnsubscribe(channel: ChannelDetails): Promise<void>;
 }

package/dist/broker/simple-exchange.js

@@ -1,10 +1,25 @@
-import { Exchange } from "./exchange.js";
+import { Exchange } from './exchange.js';
 export class SimpleExchange extends Exchange {
+    _broker;
     constructor(broker, options) {
-        super(options);
-        this.id = 'exchange';
+        super({
+            ...(options || {}),
+            id: 'exchange'
+        });
         this._broker = broker;
     }
+    async invokePublish(channelName, data) {
+        await this._broker.invokePublish(channelName, data);
+    }
+    async transmit(event, packet) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (event === '#publish') {
+            this._channelDataDemux.write(packet.channel, packet.data);
+        }
+    }
+    async transmitPublish(channelName, data) {
+        await this._broker.transmitPublish(channelName, data);
+    }
     async trySubscribe(channel) {
         channel.state = 'subscribed';
         this._channelEventDemux.write(`${channel.name}/subscribe`, { channel: channel.name });
@@ -19,15 +34,4 @@ export class SimpleExchange extends Exchange {
             this.emit('unsubscribe', { channel: channel.name });
         }
     }
-    async transmit(event, packet) {
-        if (event === '#publish') {
-            this._channelDataDemux.write(packet.channel, packet.data);
-        }
-    }
-    async transmitPublish(channelName, data) {
-        await this._broker.transmitPublish(channelName, data);
-    }
-    async invokePublish(channelName, data) {
-        await this._broker.invokePublish(channelName, data);
-    }
 }

package/dist/events/index.d.ts

@@ -0,0 +1,49 @@
+import { ChannelMap, SubscribeEvent, SubscribeFailEvent, SubscribeStateChangeEvent, UnsubscribeEvent } from '@socket-mesh/channels';
+import { ClientPrivateMap, ClientSocket, ServerPrivateMap } from '@socket-mesh/client';
+import { AuthenticateEvent, AuthStateChangeEvent, BadAuthTokenEvent, ConnectEvent, ConnectingEvent, DeauthenticateEvent, DisconnectEvent, MessageEvent, PingEvent, PongEvent, PrivateMethodMap, PublicMethodMap, RemoveAuthTokenEvent, CloseEvent as SCloseEvent, ErrorEvent as SErrorEvent, ServiceMap, TypedRequestEvent, TypedResponseEvent } from '@socket-mesh/core';
+import { IncomingMessage } from 'http';
+import { ServerSocket } from '../server-socket.js';
+export interface CloseEvent {
+}
+export interface ConnectionEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> {
+    socket: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+    upgradeReq: IncomingMessage;
+}
+export interface ErrorEvent {
+    error: Error;
+}
+export interface HandshakeEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> {
+    socket: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+}
+export interface HeadersEvent {
+    headers: string[];
+    request: IncomingMessage;
+}
+export interface ListeningEvent {
+}
+export type ServerEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = CloseEvent | ConnectionEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | ErrorEvent | HandshakeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | HeadersEvent | ListeningEvent | SocketAuthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketAuthStateChangeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketBadAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketCloseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketConnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketConnectingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketDeauthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketDisconnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketErrorEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketMessageEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketPingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketPongEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketRemoveAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketRequestEvent<TIncoming, TService, TPrivateIncoming> | SocketResponseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | WarningEvent;
+export interface ServerSocketEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> {
+    socket: ClientSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateOutgoing> | ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+}
+export type SocketAuthenticateEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = AuthenticateEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketAuthStateChangeEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = AuthStateChangeEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketBadAuthTokenEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = BadAuthTokenEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketCloseEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = SCloseEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketConnectEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = ConnectEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketConnectingEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = ConnectingEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketDeauthenticateEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = DeauthenticateEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketDisconnectEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = DisconnectEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketErrorEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = SErrorEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketMessageEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = MessageEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketPingEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = PingEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketPongEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = PongEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketRemoveAuthTokenEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = RemoveAuthTokenEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketRequestEvent<TIncoming extends PublicMethodMap, TService extends ServiceMap, TPrivateIncoming extends PrivateMethodMap> = TypedRequestEvent<TIncoming & TPrivateIncoming & ServerPrivateMap, TService>;
+export type SocketResponseEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = TypedResponseEvent<TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService> & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketSubscribeEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = SubscribeEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketSubscribeFailEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = SubscribeFailEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketSubscribeStateChangeEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = SubscribeStateChangeEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketUnsubscribeEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = UnsubscribeEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export interface WarningEvent {
+    warning: Error;
+}

package/dist/handlers/authenticate.d.ts

@@ -1,19 +1,19 @@
-import jwt from "jsonwebtoken";
-import { AuthTokenError } from "@socket-mesh/errors";
-import { AuthEngine } from "@socket-mesh/auth-engine";
-import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { ServerSocket } from "../server-socket.js";
-import { ServerTransport } from "../server-transport.js";
-import { ServerRequestHandlerArgs } from "./server-request-handler.js";
-export type AuthInfo = ValidAuthInfo | InvalidAuthInfo;
+import { AuthToken, SignedAuthToken } from '@socket-mesh/auth';
+import { AuthEngine } from '@socket-mesh/auth-engine';
+import { AuthTokenError } from '@socket-mesh/errors';
+import jwt from 'jsonwebtoken';
+import { ServerSocket } from '../server-socket.js';
+import { ServerTransport } from '../server-transport.js';
+import { ServerRequestHandlerArgs } from './server-request-handler.js';
+export type AuthInfo = InvalidAuthInfo | ValidAuthInfo;
 export interface InvalidAuthInfo {
-    signedAuthToken: SignedAuthToken;
     authError: AuthTokenError;
+    signedAuthToken: SignedAuthToken;
 }
 export interface ValidAuthInfo {
-    signedAuthToken: SignedAuthToken;
     authToken: AuthToken;
+    signedAuthToken: SignedAuthToken;
 }
 export declare function authenticateHandler({ isRpc, options: signedAuthToken, socket, transport }: ServerRequestHandlerArgs<string>): Promise<void>;
-export declare function validateAuthToken(auth: AuthEngine, authToken: SignedAuthToken, verificationOptions?: jwt.VerifyOptions): Promise<AuthInfo>;
 export declare function processAuthentication(socket: ServerSocket, transport: ServerTransport, authInfo: AuthInfo): Promise<boolean>;
+export declare function validateAuthToken(auth: AuthEngine, authToken: SignedAuthToken, verificationOptions?: jwt.VerifyOptions): Promise<AuthInfo>;

package/dist/handlers/authenticate.js

@@ -1,4 +1,6 @@
-import { AuthTokenError, AuthTokenExpiredError, AuthTokenInvalidError, AuthTokenNotBeforeError, InvalidActionError } from "@socket-mesh/errors";
+import { toError } from '@socket-mesh/core';
+import { AuthTokenError, AuthTokenExpiredError, AuthTokenInvalidError, AuthTokenNotBeforeError, InvalidActionError } from '@socket-mesh/errors';
+import jwt from 'jsonwebtoken';
 const HANDSHAKE_REJECTION_STATUS_CODE = 4008;
 ;
 export async function authenticateHandler({ isRpc, options: signedAuthToken, socket, transport }) {
@@ -9,38 +11,12 @@ export async function authenticateHandler({ isRpc, options: signedAuthToken, soc
     const authInfo = await validateAuthToken(socket.server.auth, signedAuthToken);
     await processAuthentication(socket, transport, authInfo);
 }
-export async function validateAuthToken(auth, authToken, verificationOptions) {
-    try {
-        return {
-            signedAuthToken: authToken,
-            authToken: await auth.verifyToken(authToken, verificationOptions)
-        };
-    }
-    catch (error) {
-        return {
-            signedAuthToken: authToken,
-            authError: processTokenError(error)
-        };
-    }
-}
-function processTokenError(err) {
-    if (err.name === 'TokenExpiredError' && 'expiredAt' in err) {
-        return new AuthTokenExpiredError(err.message, err.expiredAt);
-    }
-    if (err.name === 'JsonWebTokenError') {
-        return new AuthTokenInvalidError(err.message);
-    }
-    if (err.name === 'NotBeforeError' && 'date' in err) {
-        // In this case, the token is good; it's just not active yet.
-        return new AuthTokenNotBeforeError(err.message, err.date);
-    }
-    return new AuthTokenError(err.message);
-}
 export async function processAuthentication(socket, transport, authInfo) {
     if ('authError' in authInfo) {
         await transport.changeToUnauthenticatedState();
         // If the error is related to the JWT being badly formatted, then we will
         // treat the error as a socket error.
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (authInfo.signedAuthToken != null) {
             transport.onError(authInfo.authError);
             if (authInfo.authError instanceof AuthTokenError) {
@@ -65,3 +41,30 @@ export async function processAuthentication(socket, transport, authInfo) {
     }
     return await transport.setAuthorization(authInfo.signedAuthToken, authInfo.authToken);
 }
+function processTokenError(err) {
+    if (err instanceof jwt.TokenExpiredError) {
+        return new AuthTokenExpiredError(err.message, err.expiredAt);
+    }
+    if (err instanceof jwt.NotBeforeError) {
+        // In this case, the token is good; it's just not active yet.
+        return new AuthTokenNotBeforeError(err.message, err.date);
+    }
+    if (err instanceof jwt.JsonWebTokenError) {
+        return new AuthTokenInvalidError(err.message);
+    }
+    return new AuthTokenError(toError(err).message);
+}
+export async function validateAuthToken(auth, authToken, verificationOptions) {
+    try {
+        return {
+            authToken: await auth.verifyToken(authToken, verificationOptions),
+            signedAuthToken: authToken
+        };
+    }
+    catch (error) {
+        return {
+            authError: processTokenError(error),
+            signedAuthToken: authToken
+        };
+    }
+}

package/dist/handlers/handshake.d.ts

@@ -1,3 +1,3 @@
-import { HandshakeOptions, HandshakeStatus } from "@socket-mesh/client";
-import { ServerRequestHandlerArgs } from "./server-request-handler.js";
+import { HandshakeOptions, HandshakeStatus } from '@socket-mesh/client';
+import { ServerRequestHandlerArgs } from './server-request-handler.js';
 export declare function handshakeHandler({ options, socket, transport }: ServerRequestHandlerArgs<HandshakeOptions>): Promise<HandshakeStatus>;

package/dist/handlers/handshake.js

@@ -1,6 +1,6 @@
-import { wait } from "@socket-mesh/core";
-import { processAuthentication, validateAuthToken } from "./authenticate.js";
-import { dehydrateError } from "@socket-mesh/errors";
+import { toError, wait } from '@socket-mesh/core';
+import { dehydrateError } from '@socket-mesh/errors';
+import { processAuthentication, validateAuthToken } from './authenticate.js';
 const HANDSHAKE_REJECTION_STATUS_CODE = 4008;
 export async function handshakeHandler({ options, socket, transport }) {
     const server = socket.server;
@@ -10,27 +10,32 @@ export async function handshakeHandler({ options, socket, transport }) {
         if (plugin.onHandshake) {
             try {
                 await plugin.onHandshake({
+                    authInfo: 'authError' in authInfo
+                        ? { authError: authInfo.authError, signedAuthToken: options.authToken }
+                        : { authToken: authInfo.authToken, signedAuthToken: options.authToken },
                     socket,
-                    transport,
-                    authInfo: 'authError' in authInfo ?
-                        { signedAuthToken: options.authToken, authError: authInfo.authError } :
-                        { signedAuthToken: options.authToken, authToken: authInfo.authToken }
+                    transport
                 });
             }
             catch (err) {
-                if (err.statusCode == null) {
-                    err.statusCode = HANDSHAKE_REJECTION_STATUS_CODE;
+                const error = toError(err);
+                if (!('statusCode' in error)) {
+                    error.statusCode = HANDSHAKE_REJECTION_STATUS_CODE;
                 }
-                throw err;
+                throw error;
             }
         }
     }
     let authError = undefined;
-    let changed;
+    let changed = false;
     try {
         changed = await processAuthentication(socket, transport, authInfo);
         if (socket.status === 'closed') {
-            return;
+            return {
+                authToken: options.authToken,
+                id: socket.id,
+                pingTimeoutMs: server.pingTimeoutMs
+            };
         }
     }
     catch (err) {
@@ -48,14 +53,14 @@ export async function handshakeHandler({ options, socket, transport }) {
     }
     if (authError) {
         return {
+            authError,
             id: socket.id,
-            pingTimeoutMs: server.pingTimeoutMs,
-            authError
+            pingTimeoutMs: server.pingTimeoutMs
         };
     }
     return {
+        authToken: options.authToken,
         id: socket.id,
-        pingTimeoutMs: server.pingTimeoutMs,
-        authToken: options.authToken
+        pingTimeoutMs: server.pingTimeoutMs
     };
 }

package/dist/handlers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './authenticate.js';
+export * from './handshake.js';
+export * from './publish.js';
+export * from './remove-auth-token.js';
+export * from './server-request-handler.js';
+export * from './subscribe.js';
+export * from './unsubscribe.js';

package/dist/handlers/index.js

@@ -0,0 +1,7 @@
+export * from './authenticate.js';
+export * from './handshake.js';
+export * from './publish.js';
+export * from './remove-auth-token.js';
+export * from './server-request-handler.js';
+export * from './subscribe.js';
+export * from './unsubscribe.js';

package/dist/handlers/publish.d.ts

@@ -1,5 +1,5 @@
-import { PublishOptions } from "@socket-mesh/channels";
-import { ServerRequestHandlerArgs } from "./server-request-handler.js";
-export declare function publishHandler({ socket, transport, options }: ServerRequestHandlerArgs<PublishOptions, {}, {
+import { PublishOptions } from '@socket-mesh/channels';
+import { ServerRequestHandlerArgs } from './server-request-handler.js';
+export declare function publishHandler({ options, socket, transport }: ServerRequestHandlerArgs<PublishOptions, {}, {}, {
     [channel: string]: any;
 }>): Promise<void>;

package/dist/handlers/publish.js

@@ -1,5 +1,5 @@
-import { InvalidActionError } from "@socket-mesh/errors";
-export async function publishHandler({ socket, transport, options }) {
+import { InvalidActionError } from '@socket-mesh/errors';
+export async function publishHandler({ options, socket, transport }) {
     if (!socket.server.allowClientPublish) {
         throw new InvalidActionError('Client publish feature is disabled');
     }

package/dist/handlers/remove-auth-token.d.ts

@@ -1,4 +1,4 @@
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-import { SocketTransport } from "@socket-mesh/core";
-import { ServerSocketState } from "../server-socket-state.js";
-export declare function deauthenticate(transport: SocketTransport<ServerPrivateMap, {}, ClientPrivateMap, {}, ServerSocketState>): Promise<boolean>;
+import { ClientPrivateMap } from '@socket-mesh/client';
+import { SocketTransport } from '@socket-mesh/core';
+import { ServerSocketState } from '../server-socket-state.js';
+export declare function deauthenticate(transport: SocketTransport<{}, {}, ServerSocketState, {}, {}, ClientPrivateMap>): Promise<boolean>;

package/dist/handlers/server-request-handler.d.ts

@@ -1,7 +1,6 @@
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-import { PrivateMethodMap, PublicMethodMap, RequestHandlerArgs, ServiceMap } from "@socket-mesh/core";
-import { ServerSocketState } from "../server-socket-state.js";
-import { ServerSocket } from "../server-socket.js";
-import { ServerTransport } from "../server-transport.js";
-import { ChannelMap } from "@socket-mesh/channels";
-export type ServerRequestHandlerArgs<TOptions, TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> = RequestHandlerArgs<TOptions, TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState, ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>, ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
+import { ChannelMap } from '@socket-mesh/channels';
+import { PrivateMethodMap, PublicMethodMap, RequestHandlerArgs, ServiceMap } from '@socket-mesh/core';
+import { ServerSocketState } from '../server-socket-state.js';
+import { ServerSocket } from '../server-socket.js';
+import { ServerTransport } from '../server-transport.js';
+export type ServerRequestHandlerArgs<TOptions, TIncoming extends PublicMethodMap = any, TOutgoing extends PublicMethodMap = any, TChannel extends ChannelMap = any, TService extends ServiceMap = any, TState extends object = any, TPrivateIncoming extends PrivateMethodMap = any, TPrivateOutgoing extends PrivateMethodMap = any, TServerState extends object = any> = RequestHandlerArgs<TOptions, TState & ServerSocketState, ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>, ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;

package/dist/handlers/subscribe.d.ts

@@ -1,3 +1,3 @@
-import { SubscribeOptions } from "@socket-mesh/client";
-import { ServerRequestHandlerArgs } from "./server-request-handler.js";
-export declare function subscribeHandler({ socket, transport, options }: ServerRequestHandlerArgs<SubscribeOptions>): Promise<void>;
+import { SubscribeOptions } from '@socket-mesh/client';
+import { ServerRequestHandlerArgs } from './server-request-handler.js';
+export declare function subscribeHandler({ options, socket, transport }: ServerRequestHandlerArgs<SubscribeOptions>): Promise<void>;

package/dist/handlers/subscribe.js

@@ -1,5 +1,5 @@
-import { BrokerError, InvalidActionError } from "@socket-mesh/errors";
-export async function subscribeHandler({ socket, transport, options }) {
+import { BrokerError, InvalidActionError } from '@socket-mesh/errors';
+export async function subscribeHandler({ options, socket, transport }) {
     if (socket.status !== 'ready') {
         // This is an invalid state; it means the client tried to subscribe before
         // having completed the handshake.
@@ -7,7 +7,7 @@ export async function subscribeHandler({ socket, transport, options }) {
     }
     const state = socket.state;
     const server = socket.server;
-    if (server.socketChannelLimit && state.channelSubscriptionsCount >= server.socketChannelLimit) {
+    if (server.socketChannelLimit && (state.channelSubscriptionsCount || 0) >= server.socketChannelLimit) {
         throw new InvalidActionError(`Socket ${socket.id} tried to exceed the channel subscription limit of ${server.socketChannelLimit}`);
     }
     const { channel, ...channelOptions } = options;