@socket-mesh/server 18.1.4 → 18.1.5

package/dist/handlers/unsubscribe.d.ts

@@ -1,2 +1,2 @@
-import { ServerRequestHandlerArgs } from "./server-request-handler.js";
-export declare function unsubscribeHandler({ transport, options: channel }: ServerRequestHandlerArgs<string>): Promise<void>;
+import { ServerRequestHandlerArgs } from './server-request-handler.js';
+export declare function unsubscribeHandler({ options: channel, transport }: ServerRequestHandlerArgs<string>): Promise<void>;

package/dist/handlers/unsubscribe.js

@@ -1,5 +1,5 @@
-import { BrokerError } from "@socket-mesh/errors";
-export async function unsubscribeHandler({ transport, options: channel }) {
+import { BrokerError } from '@socket-mesh/errors';
+export async function unsubscribeHandler({ options: channel, transport }) {
     try {
         await transport.unsubscribe(channel);
     }

package/dist/index.d.ts

@@ -1,30 +1,32 @@
-import http from "http";
-import { Server } from "./server.js";
-import { ServerOptions } from "./server-options.js";
-import { ChannelMap } from "@socket-mesh/channels";
-import { PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
-export { Server } from "./server.js";
-export { ServerSocket } from "./server-socket.js";
-export { PluginType } from "@socket-mesh/core";
-export { ServerRequestHandlerArgs } from './handlers/server-request-handler.js';
+import { ChannelMap } from '@socket-mesh/channels';
+import { PrivateMethodMap, PublicMethodMap, ServiceMap } from '@socket-mesh/core';
+import http from 'http';
+import { ServerOptions } from './server-options.js';
+import { Server } from './server.js';
+export type { ServerRequestHandlerArgs } from './handlers/server-request-handler.js';
+export type { ServerOptions } from './server-options.js';
+export type { ServerSocketState } from './server-socket-state.js';
+export { ServerSocket } from './server-socket.js';
+export { Server } from './server.js';
+export type { PluginType } from '@socket-mesh/core';
 /**
- * Creates an http.Server exclusively used for WS upgrades.
+ * Captures upgrade requests for a http.Server.
  *
- * @param {Number} port
- * @param {Function} callback
+ * @param {http.Server} server
  * @param {Object} options
  * @return {AGServer} websocket cluster server
  * @api public
  */
-export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(port: number, options: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(port: number, options: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>, fn: () => void): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export declare function attach<TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(server: http.Server, options?: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
 /**
- * Captures upgrade requests for a http.Server.
+ * Creates an http.Server exclusively used for WS upgrades.
  *
- * @param {http.Server} server
+ * @param {Number} port
+ * @param {Function} callback
  * @param {Object} options
  * @return {AGServer} websocket cluster server
  * @api public
  */
-export declare function attach<TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(server: http.Server, options?: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(port: number, options: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(port: number, options: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>, fn: () => void): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;

package/dist/index.js

@@ -1,7 +1,22 @@
-import http from "http";
-import { Server } from "./server.js";
-export { Server } from "./server.js";
-export { ServerSocket } from "./server-socket.js";
+import http from 'http';
+import { Server } from './server.js';
+export { ServerSocket } from './server-socket.js';
+export { Server } from './server.js';
+/**
+ * Captures upgrade requests for a http.Server.
+ *
+ * @param {http.Server} server
+ * @param {Object} options
+ * @return {AGServer} websocket cluster server
+ * @api public
+ */
+export function attach(server, options) {
+    if (options == null) {
+        options = {};
+    }
+    options.server = server;
+    return new Server(options);
+}
 export function listen(port, options, fn) {
     if (typeof options === 'function') {
         fn = options;
@@ -20,19 +35,3 @@ export function listen(port, options, fn) {
     return socketClusterServer;
 }
 ;
-/**
- * Captures upgrade requests for a http.Server.
- *
- * @param {http.Server} server
- * @param {Object} options
- * @return {AGServer} websocket cluster server
- * @api public
- */
-export function attach(server, options) {
-    if (options == null) {
-        options = {};
-    }
-    options.server = server;
-    return new Server(options);
-}
-;

package/dist/plugin/server-plugin.d.ts

@@ -1,15 +1,15 @@
-import { IncomingMessage } from "http";
-import { Plugin, PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
-import { AuthInfo } from "../handlers/authenticate.js";
-import { ServerSocket } from "../server-socket.js";
-import { ServerTransport } from "../server-transport.js";
-import { ChannelMap, ChannelOptions } from "@socket-mesh/channels";
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-import { ServerSocketState } from "../server-socket-state.js";
+import { ChannelMap, ChannelOptions } from '@socket-mesh/channels';
+import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
+import { Plugin, PrivateMethodMap, PublicMethodMap, ServiceMap } from '@socket-mesh/core';
+import { IncomingMessage } from 'http';
+import { AuthInfo } from '../handlers/authenticate.js';
+import { ServerSocketState } from '../server-socket-state.js';
+import { ServerSocket } from '../server-socket.js';
+import { ServerTransport } from '../server-transport.js';
 export interface HandshakePluginArgs<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
+    authInfo: AuthInfo;
     socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-    authInfo: AuthInfo;
 }
 export interface PublishPluginArgs<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
     channel: string;
@@ -17,12 +17,6 @@ export interface PublishPluginArgs<TChannel extends ChannelMap, TService extends
     socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
 }
-export interface SubscribePluginArgs<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
-    channel: string;
-    options: ChannelOptions;
-    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-    transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-}
 export interface ServerPlugin<TIncoming extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> extends Plugin<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
     onAuthenticate?: (authInfo: AuthInfo) => void;
     onConnection?: (request: IncomingMessage) => Promise<void>;
@@ -31,3 +25,9 @@ export interface ServerPlugin<TIncoming extends PublicMethodMap, TChannel extend
     onPublishOut?: (options: PublishPluginArgs<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>) => Promise<any>;
     onSubscribe?: (options: SubscribePluginArgs<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>) => Promise<void>;
 }
+export interface SubscribePluginArgs<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
+    channel: string;
+    options: ChannelOptions;
+    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+}

package/dist/server-options.d.ts

@@ -1,25 +1,25 @@
-import ws from "ws";
-import { AuthEngine, AuthOptions } from "@socket-mesh/auth-engine";
-import { CallIdGenerator, HandlerMap, StreamCleanupMode, ServiceMap, PublicMethodMap, PrivateMethodMap } from "@socket-mesh/core";
-import { CodecEngine } from "@socket-mesh/formatter";
-import { ServerPlugin } from "./plugin/server-plugin.js";
-import { Broker } from "./broker/broker.js";
-import { ChannelMap } from "@socket-mesh/channels";
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-export interface ServerOptions<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> extends ws.ServerOptions {
+import { AuthEngine, AuthOptions } from '@socket-mesh/auth-engine';
+import { ChannelMap } from '@socket-mesh/channels';
+import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
+import { CallIdGenerator, HandlerMap, PrivateMethodMap, PublicMethodMap, ServiceMap, StreamCleanupMode } from '@socket-mesh/core';
+import { CodecEngine } from '@socket-mesh/formatter';
+import { ServerOptions as WebSocketServerOptions } from 'ws';
+import { Broker } from './broker/broker.js';
+import { ServerPlugin } from './plugin/server-plugin.js';
+export interface ServerOptions<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> extends WebSocketServerOptions {
     ackTimeoutMs?: number;
     allowClientPublish?: boolean;
     authEngine?: AuthEngine | AuthOptions;
     brokerEngine?: Broker<TChannel>;
     callIdGenerator?: CallIdGenerator;
     codecEngine?: CodecEngine;
-    handshakeTimeoutMs?: number;
     handlers?: HandlerMap<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState>;
+    handshakeTimeoutMs?: number;
     isPingTimeoutDisabled?: boolean;
-    plugins?: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
     origins?: string;
     pingIntervalMs?: number;
     pingTimeoutMs?: number;
+    plugins?: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
     socketChannelLimit?: number;
     socketStreamCleanupMode?: StreamCleanupMode;
     strictHandshake?: boolean;

package/dist/server-socket.d.ts

@@ -1,29 +1,30 @@
-import { HandlerMap, PrivateMethodMap, PublicMethodMap, ServiceMap, Socket, SocketOptions } from "@socket-mesh/core";
-import ws from "ws";
-import { Exchange } from "./broker/exchange.js";
-import { Server } from "./server.js";
-import { IncomingMessage } from "http";
-import { ServerPlugin } from "./plugin/server-plugin.js";
-import { ChannelMap } from "@socket-mesh/channels";
-import { ServerSocketState } from "./server-socket-state.js";
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
+import { ChannelMap } from '@socket-mesh/channels';
+import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
+import { HandlerMap, PrivateMethodMap, PublicMethodMap, ServiceMap, Socket, SocketOptions } from '@socket-mesh/core';
+import { IncomingMessage } from 'http';
+import { WebSocket } from 'ws';
+import { Exchange } from './broker/exchange.js';
+import { ServerPlugin } from './plugin/server-plugin.js';
+import { ServerSocketState } from './server-socket-state.js';
+import { Server } from './server.js';
 export interface ServerSocketOptions<TIncoming extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> extends SocketOptions<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
     handlers: HandlerMap<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState>;
-    plugins?: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
     id?: string;
-    service?: string;
-    server: Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    plugins?: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
     request: IncomingMessage;
-    socket: ws.WebSocket;
+    server: Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    service?: string;
+    socket: WebSocket;
 }
 export declare class ServerSocket<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> extends Socket<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
-    readonly server: Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     private _serverTransport;
+    readonly server: Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     constructor(options: ServerSocketOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
     deauthenticate(rejectOnFailedDelivery?: boolean): Promise<boolean>;
     get exchange(): Exchange<TChannel>;
+    get id(): string;
     kickOut(channel: string, message: string): Promise<void[]>;
     ping(): Promise<void>;
-    get service(): string;
+    get service(): string | undefined;
     get type(): 'server';
 }

package/dist/server-socket.js

@@ -1,6 +1,8 @@
-import { Socket } from "@socket-mesh/core";
-import { ServerTransport } from "./server-transport.js";
+import { Socket } from '@socket-mesh/core';
+import { ServerTransport } from './server-transport.js';
 export class ServerSocket extends Socket {
+    _serverTransport;
+    server;
     constructor(options) {
         const transport = new ServerTransport(options);
         super(transport, options);
@@ -8,7 +10,7 @@ export class ServerSocket extends Socket {
         this._serverTransport = transport;
     }
     async deauthenticate(rejectOnFailedDelivery) {
-        await super.deauthenticate();
+        const result = await super.deauthenticate();
         if (rejectOnFailedDelivery) {
             try {
                 await this._serverTransport.invoke('#removeAuthToken', undefined)[0];
@@ -17,7 +19,7 @@ export class ServerSocket extends Socket {
                 this._serverTransport.onError(error);
                 throw error;
             }
-            return;
+            return result;
         }
         try {
             await this.transmit('#removeAuthToken');
@@ -27,12 +29,16 @@ export class ServerSocket extends Socket {
                 throw err;
             }
         }
+        return result;
     }
     get exchange() {
         return this.server.exchange;
     }
+    get id() {
+        return this._serverTransport.id;
+    }
     kickOut(channel, message) {
-        const channels = channel ? [channel] : Object.keys(this.state.channelSubscriptions);
+        const channels = channel ? [channel] : Object.keys(this.state.channelSubscriptions || {});
         return Promise.all(channels.map((channelName) => {
             this.transmit('#kickOut', { channel: channelName, message });
             return this._serverTransport.unsubscribe(channelName);

package/dist/server-transport.d.ts

@@ -1,21 +1,23 @@
-import { ServerSocket, ServerSocketOptions } from "./server-socket.js";
-import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { AuthTokenOptions } from "@socket-mesh/auth-engine";
-import { Data } from "ws";
-import { AnyPacket, AnyResponse, SocketStatus, SocketTransport, InvokeMethodRequest, InvokeServiceRequest, TransmitMethodRequest, TransmitServiceRequest, InboundMessage, ServiceMap, PublicMethodMap, PrivateMethodMap } from "@socket-mesh/core";
-import { IncomingMessage } from "http";
-import { ServerPlugin } from "./plugin/server-plugin.js";
-import { ChannelMap, PublishOptions } from "@socket-mesh/channels";
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-import { ServerSocketState } from "./server-socket-state.js";
+import { AuthToken, SignedAuthToken } from '@socket-mesh/auth';
+import { AuthTokenOptions } from '@socket-mesh/auth-engine';
+import { ChannelMap, PublishOptions } from '@socket-mesh/channels';
+import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
+import { AnyPacket, AnyResponse, InboundMessage, InvokeMethodRequest, InvokeServiceRequest, PrivateMethodMap, PublicMethodMap, ServiceMap, SocketStatus, SocketTransport, TransmitMethodRequest, TransmitServiceRequest } from '@socket-mesh/core';
+import { IncomingMessage } from 'http';
+import { Data } from 'ws';
+import { ServerPlugin } from './plugin/server-plugin.js';
+import { ServerSocketState } from './server-socket-state.js';
+import { ServerSocket, ServerSocketOptions } from './server-socket.js';
 export declare class ServerTransport<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> extends SocketTransport<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
+    id: string;
     readonly plugins: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
-    readonly service?: string;
     readonly request: IncomingMessage;
+    readonly service?: string;
+    type: 'server';
     constructor(options: ServerSocketOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
     changeToUnauthenticatedState(): Promise<boolean>;
     protected handleInboudMessage({ packet, timestamp }: InboundMessage<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService>): Promise<void>;
-    protected onClose(code: number, reason?: string | Buffer): void;
+    protected onClose(code: number, reason?: Buffer | string): void;
     protected onDisconnect(status: SocketStatus, code: number, reason?: string): void;
     onError(error: Error): void;
     protected onInvoke<TServiceName extends keyof TService, TServiceMethod extends keyof TService[TServiceName], TMethod extends keyof TOutgoing, TPrivateMethod extends keyof TPrivateOutgoing>(request: InvokeMethodRequest<TOutgoing, TMethod> | InvokeMethodRequest<TPrivateOutgoing, TPrivateMethod> | InvokeServiceRequest<TService, TServiceName, TServiceMethod>): void;
@@ -32,6 +34,5 @@ export declare class ServerTransport<TIncoming extends PublicMethodMap = {}, TCh
     get socket(): ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     set socket(value: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
     triggerAuthenticationEvents(wasSigned: boolean, wasAuthenticated: boolean): void;
-    type: 'server';
     unsubscribe(channel: string): Promise<void>;
 }

package/dist/server-transport.js

@@ -1,12 +1,17 @@
-import { AuthError, BrokerError, InvalidActionError, socketProtocolErrorStatuses } from "@socket-mesh/errors";
-import { SocketTransport, abortRequest } from "@socket-mesh/core";
-import base64id from "base64id";
+import { abortRequest, SocketTransport } from '@socket-mesh/core';
+import { AuthError, BrokerError, InvalidActionError, SocketProtocolErrorStatuses } from '@socket-mesh/errors';
+import base64id from 'base64id';
 export class ServerTransport extends SocketTransport {
+    id;
+    plugins;
+    request;
+    service;
+    type;
     constructor(options) {
         super(options);
         this.type = 'server';
         this.request = options.request;
-        this.plugins = options.plugins;
+        this.plugins = options.plugins || [];
         this.service = options.service;
         this.webSocket = options.socket;
         this.id = (options.id || base64id.generateId());
@@ -17,38 +22,38 @@ export class ServerTransport extends SocketTransport {
         if (this.signedAuthToken) {
             const authToken = this.authToken;
             const signedAuthToken = this.signedAuthToken;
-            this.socket.server.emit('socketAuthStateChange', { socket: this.socket, wasAuthenticated: true, isAuthenticated: false });
+            this.socket.server.emit('socketAuthStateChange', { isAuthenticated: false, socket: this.socket, wasAuthenticated: true });
             await super.changeToUnauthenticatedState();
-            this.socket.server.emit('socketDeauthenticate', { socket: this.socket, signedAuthToken, authToken });
+            this.socket.server.emit('socketDeauthenticate', { authToken, signedAuthToken, socket: this.socket });
             return true;
         }
         return false;
     }
-    handleInboudMessage({ packet, timestamp }) {
+    async handleInboudMessage({ packet, timestamp }) {
         if ((packet === null || typeof packet !== 'object') && this.socket.server.strictHandshake && this.status === 'connecting') {
             this.disconnect(4009);
             return;
         }
-        return super.handleInboudMessage({ packet, timestamp });
+        return await super.handleInboudMessage({ packet, timestamp });
     }
     onClose(code, reason) {
         const status = this.status;
-        const strReason = reason?.toString() || socketProtocolErrorStatuses[code];
+        const strReason = reason?.toString() || SocketProtocolErrorStatuses[code];
         super.onClose(code, reason);
-        this.socket.server.emit('socketClose', { socket: this.socket, code, reason: strReason });
+        this.socket.server.emit('socketClose', { code, reason: strReason, socket: this.socket });
         this.onDisconnect(status, code, strReason);
     }
     onDisconnect(status, code, reason) {
         if (status === 'ready') {
-            this.socket.server.emit('socketDisconnect', { socket: this.socket, code, reason });
+            this.socket.server.emit('socketDisconnect', { code, reason, socket: this.socket });
         }
         else {
-            this.socket.server.emit('socketConnectAbort', { socket: this.socket, code, reason });
+            this.socket.server.emit('socketConnectAbort', { code, reason, socket: this.socket });
         }
         super.onDisconnect(status, code, reason);
         if (this.socket.state.channelSubscriptions) {
             const channels = Object.keys(this.socket.state.channelSubscriptions);
-            channels.map((channel) => this.unsubscribe(channel));
+            channels.map(channel => this.unsubscribe(channel));
         }
         if (this.streamCleanupMode !== 'none') {
             (async () => {
@@ -61,7 +66,7 @@ export class ServerTransport extends SocketTransport {
                 }
                 for (let i = 0; i < this.plugins.length; i++) {
                     const plugin = this.plugins[i];
-                    if (plugin.onEnd) {
+                    if (plugin?.onEnd) {
                         plugin.onEnd({ socket: this.socket, transport: this });
                     }
                 }
@@ -71,7 +76,7 @@ export class ServerTransport extends SocketTransport {
     }
     onError(error) {
         super.onError(error);
-        this.socket.server.emit('socketError', { socket: this.socket, error });
+        this.socket.server.emit('socketError', { error, socket: this.socket });
     }
     onInvoke(request) {
         if (request.method !== '#publish') {
@@ -82,25 +87,25 @@ export class ServerTransport extends SocketTransport {
             .then(() => {
             super.onInvoke(request);
         })
-            .catch(err => {
+            .catch((err) => {
             abortRequest(request, err);
         });
     }
+    /*
+    protected override onPing(data: Buffer): void {
+        if (this.socket.server.strictHandshake && this.status === 'connecting') {
+            this.disconnect(4009);
+            return;
+        }
+
+        super.onPing(data);
+        this.socket.server.emit('socketPing', { socket: this.socket, data });
+    }
+*/
     onMessage(data, isBinary) {
-        this.socket.server.emit('socketMessage', { socket: this.socket, data, isBinary });
+        this.socket.server.emit('socketMessage', { data, isBinary, socket: this.socket });
         super.onMessage(data, isBinary);
     }
-    /*
-        protected override onPing(data: Buffer): void {
-            if (this.socket.server.strictHandshake && this.status === 'connecting') {
-                this.disconnect(4009);
-                return;
-            }
-    
-            super.onPing(data);
-            this.socket.server.emit('socketPing', { socket: this.socket, data });
-        }
-    */
     onPingPong() {
         if (this.socket.server.strictHandshake && this.status === 'connecting') {
             this.disconnect(4009);
@@ -113,8 +118,8 @@ export class ServerTransport extends SocketTransport {
     async onPublish(options) {
         let data = options.data;
         for (const plugin of this.plugins) {
-            if ('onPublishOut' in plugin) {
-                data = await plugin.onPublishOut({ socket: this.socket, transport: this, channel: options.channel, data });
+            if (plugin.onPublishOut) {
+                data = await plugin.onPublishOut({ channel: options.channel, data, socket: this.socket, transport: this });
             }
         }
         options.data = data;
@@ -135,7 +140,7 @@ export class ServerTransport extends SocketTransport {
     }
     onResponse(response) {
         super.onResponse(response);
-        this.socket.server.emit('socketResponse', { socket: this.socket, response });
+        this.socket.server.emit('socketResponse', { response, socket: this.socket });
     }
     onTransmit(request) {
         if (request.method !== '#publish') {
@@ -146,7 +151,7 @@ export class ServerTransport extends SocketTransport {
             .then(() => {
             super.onTransmit(request);
         })
-            .catch(err => {
+            .catch((err) => {
             abortRequest(request, err);
         });
     }
@@ -197,7 +202,7 @@ export class ServerTransport extends SocketTransport {
                 this.onError(error);
                 throw error;
             }
-            return;
+            return changed;
         }
         try {
             await this.transmit('#setAuthToken', signedAuthToken);
@@ -211,7 +216,7 @@ export class ServerTransport extends SocketTransport {
     }
     setReadyStatus(pingTimeoutMs, authError) {
         super.setReadyStatus(pingTimeoutMs, authError);
-        this.socket.server.emit('socketConnect', { socket: this.socket, pingTimeoutMs, id: this.socket.id, isAuthenticated: !!this.signedAuthToken, authError });
+        this.socket.server.emit('socketConnect', { authError, id: this.socket.id, isAuthenticated: !!this.signedAuthToken, pingTimeoutMs, socket: this.socket });
     }
     get socket() {
         return super.socket;
@@ -220,9 +225,12 @@ export class ServerTransport extends SocketTransport {
         super.socket = value;
     }
     triggerAuthenticationEvents(wasSigned, wasAuthenticated) {
+        if (!this.signedAuthToken) {
+            throw new AuthError('Signed auth token should be set to trigger authentication events');
+        }
         super.triggerAuthenticationEvents(wasSigned, wasAuthenticated);
-        this.socket.server.emit('socketAuthStateChange', { socket: this.socket, wasAuthenticated, isAuthenticated: true, authToken: this.authToken, signedAuthToken: this.signedAuthToken });
-        this.socket.server.emit('socketAuthenticate', { socket: this.socket, wasSigned, signedAuthToken: this.signedAuthToken, authToken: this.authToken });
+        this.socket.server.emit('socketAuthStateChange', { authToken: this.authToken, isAuthenticated: true, signedAuthToken: this.signedAuthToken, socket: this.socket, wasAuthenticated });
+        this.socket.server.emit('socketAuthenticate', { authToken: this.authToken, signedAuthToken: this.signedAuthToken, socket: this.socket, wasSigned });
     }
     async unsubscribe(channel) {
         if (typeof channel !== 'string') {