@socket-mesh/server 17.3.5 → 17.3.7

package/action.d.ts

@@ -5,8 +5,8 @@ import { AuthState, AuthToken, SignedAuthToken } from "@socket-mesh/auth";
 import { IncomingMessage } from 'http';
 import { DataPacket } from "@socket-mesh/simple-broker";
 import { ChannelOptions } from "@socket-mesh/channel";
-import { Request } from "@socket-mesh/request";
 import { ServerSocket } from "./serversocket";
+import { HandshakeRequest } from "./request";
 export declare enum ActionType {
     HANDSHAKE_WS = "handshakeWS",
     HANDSHAKE_SC = "handshakeSC",
@@ -32,11 +32,12 @@ export declare abstract class Action<T, U extends ActionType = ActionType> {
     private _resolve;
     private _reject;
     constructor(type: U);
-    allow(packet?: ActionResult<T>): void;
-    block(error: Error): void;
+    allow: (packet?: ActionResult<T>) => void;
+    block: (error: Error) => void;
 }
 export type MiddlewareAction<T> = ActionTransmit<T> | ActionInvoke<T> | ActionPublishIn<T> | ActionPublishOut<T> | ActionSubscribe<T> | ActionHandshakeSC<T> | ActionHandshakeWS | ActionAuthenticate<T> | ActionMessage<T>;
 export type InboundAction<T> = ActionAuthenticate<T> | ActionTransmit<T> | ActionInvoke<T> | ActionPublishIn<T> | ActionSubscribe<T>;
+export type HandshakeAction<T> = ActionHandshakeSC<T> | ActionHandshakeWS;
 export declare class ActionHandshakeWS extends Action<undefined, ActionType.HANDSHAKE_WS> {
     constructor(request: IncomingMessage);
     request: IncomingMessage;
@@ -53,12 +54,8 @@ export type AuthInfo = {
     authState: AuthState;
 };
 export declare class ActionHandshakeSC<T> extends Action<AuthInfo, ActionType.HANDSHAKE_SC> {
-    constructor(socket: ServerSocket<T>, request: Request<{
-        authToken: string;
-    }>, data: AuthInfo);
-    request: Request<{
-        authToken: string;
-    }>;
+    constructor(socket: ServerSocket<T>, request: HandshakeRequest, data: AuthInfo);
+    request: HandshakeRequest;
     socket: ServerSocket<T>;
     data: AuthInfo;
 }
@@ -85,7 +82,7 @@ export declare class ActionSubscribe<T> extends Action<ChannelOptions, ActionTyp
     constructor(socket: ServerSocket<T>, packet?: DataPacket<ChannelOptions>);
     socket: ServerSocket<T>;
     authTokenExpiredError?: AuthTokenExpiredError;
-    channel?: string;
+    channel: string;
     data?: ChannelOptions;
 }
 export declare class ActionPublishIn<T> extends Action<T, ActionType.PUBLISH_IN> {

package/action.js

@@ -13,6 +13,20 @@ export var ActionType;
 })(ActionType || (ActionType = {}));
 export class Action {
     constructor(type) {
+        this.allow = (packet) => {
+            if (this.outcome) {
+                throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot allow`);
+            }
+            this.outcome = 'allowed';
+            this._resolve(packet);
+        };
+        this.block = (error) => {
+            if (this.outcome) {
+                throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot block`);
+            }
+            this.outcome = 'blocked';
+            this._reject(error);
+        };
         this.type = type;
         this.outcome = null;
         this.promise = new Promise((resolve, reject) => {
@@ -20,20 +34,6 @@ export class Action {
             this._reject = reject;
         });
     }
-    allow(packet) {
-        if (this.outcome) {
-            throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot allow`);
-        }
-        this.outcome = 'allowed';
-        this._resolve(packet);
-    }
-    block(error) {
-        if (this.outcome) {
-            throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot block`);
-        }
-        this.outcome = 'blocked';
-        this._reject(error);
-    }
 }
 export class ActionHandshakeWS extends Action {
     constructor(request) {

package/auth-engine.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import jwt from 'jsonwebtoken';
+import { ServerSocket } from './serversocket';
+export interface AuthTokenOptions extends jwt.SignOptions {
+    rejectOnFailedDelivery?: boolean;
+}
+export interface VerifyOptions<T> extends jwt.VerifyOptions {
+    socket: ServerSocket<T>;
+}
+export declare class AuthEngine<T> {
+    verifyToken(signedToken: string, key: jwt.Secret | jwt.GetPublicKeyOrSecret, options: VerifyOptions<T>): Promise<jwt.JwtPayload>;
+    signToken(token: string | object | Buffer, key: jwt.Secret, options: jwt.SignOptions): Promise<string>;
+}

package/auth-engine.js

@@ -0,0 +1,32 @@
+import jwt from 'jsonwebtoken';
+import { InvalidArgumentsError } from '@socket-mesh/errors';
+export class AuthEngine {
+    verifyToken(signedToken, key, options) {
+        const jwtOptions = Object.assign({}, options || {});
+        if (typeof signedToken === 'string' || signedToken == null) {
+            return new Promise((resolve, reject) => {
+                const cb = (err, token) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(token);
+                };
+                jwt.verify(signedToken || '', key, jwtOptions, cb);
+            });
+        }
+        return Promise.reject(new InvalidArgumentsError('Invalid token format - Token must be a string'));
+    }
+    signToken(token, key, options) {
+        const jwtOptions = Object.assign({}, options || {});
+        return new Promise((resolve, reject) => {
+            jwt.sign(token, key, jwtOptions, (err, signedToken) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(signedToken);
+            });
+        });
+    }
+}

package/events.d.ts

@@ -6,16 +6,16 @@ export type RawMessage = {
     message: string | ArrayBuffer | Buffer[];
 };
 export interface AuthStateChanged extends AuthStateChange {
-    authToken?: AuthToken | null;
+    authToken?: AuthToken;
 }
 export interface AuthTokenSigned {
     signedAuthToken: SignedAuthToken;
 }
 export interface Authenticated {
-    authToken?: AuthToken | null;
+    authToken: AuthToken;
 }
 export interface Deauthenticated {
-    oldAuthToken?: AuthToken | null;
+    oldAuthToken: AuthToken;
 }
 export interface BadAuthToken {
     authError: Error;

package/middleware-stream.d.ts

@@ -1,7 +1,7 @@
 import { WritableConsumableStream } from "@socket-mesh/writable-consumable-stream";
 import { MiddlewareType } from "./middleware-type";
-import { Action } from "./action";
-export declare class MiddlewareStream<T> extends WritableConsumableStream<Action<T>> {
+import { Action, ActionType } from "./action";
+export declare class MiddlewareStream<T extends Action<any, ActionType>> extends WritableConsumableStream<T> {
     readonly type: MiddlewareType;
     constructor(type: MiddlewareType);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@socket-mesh/server",
-  "version": "17.3.5",
+  "version": "17.3.7",
   "description": "Server module for SocketMesh",
   "main": "index.js",
   "type": "module",
@@ -9,23 +9,23 @@
     "url": "git://github.com/socket-mesh/server.git"
   },
   "dependencies": {
-    "@socket-mesh/async-stream-emitter": "^4.2.4",
+    "@socket-mesh/async-stream-emitter": "^4.2.7",
 		"@socket-mesh/consumable-stream": "3.2.0",
     "@socket-mesh/auth": "^2.1.5",
     "@socket-mesh/errors": "^3.0.4",
     "@socket-mesh/formatter": "^4.0.3",
-    "@socket-mesh/request": "^2.0.3",
-    "@socket-mesh/server-auth": "^0.0.3",
-    "@socket-mesh/simple-broker": "^5.1.5",
-    "@socket-mesh/stream-demux": "^9.0.5",
+    "@socket-mesh/request": "^2.0.6",
+    "@socket-mesh/simple-broker": "^5.1.6",
+    "@socket-mesh/stream-demux": "^9.0.7",
     "@socket-mesh/writable-consumable-stream": "^4.2.0",
-		"@socket-mesh/channel": "6.0.15",
+		"@socket-mesh/channel": "6.0.18",
     "base64id": "^2.0.0",
     "clone-deep": "^4.0.1",
     "jsonwebtoken": "^9.0.0",
     "ws": "^8.13.0"
   },
   "devDependencies": {
+		"@socket-mesh/client": "^17.1.4",
     "@socket-mesh/local-storage": "^1.0.0",
     "@types/base64id": "^2.0.0",
     "@types/clone-deep": "^4.0.1",

package/request.d.ts

@@ -1,26 +1,24 @@
-import { Request } from "@socket-mesh/request";
-import { RequestSocket } from "@socket-mesh/request/request";
+import { Request, RequestSocket, RequestWithResponse } from "@socket-mesh/request";
 import { Connected } from "./events";
 import { DataPacket } from "@socket-mesh/simple-broker";
 import { ChannelOptions } from "@socket-mesh/channel";
-export type InboundRequest<T> = HandshakeRequest | SubscribeRequest | UnsubscribeRequest | AuthenticateRequest | PublishRequest<T>;
+export type InboundRequest<T> = HandshakeRequest | SubscribeRequest | UnsubscribeRequest | AuthenticateRequest | PublishRequest<T> | InvokeRequest<T>;
 export interface HandshakeData {
     authToken: string;
 }
-export declare class HandshakeRequest extends Request<HandshakeData, Connected> {
+export declare class HandshakeRequest extends RequestWithResponse<HandshakeData, Connected> {
     constructor(socket: RequestSocket, id: number, procedureName: '#handshake', data: HandshakeData);
 }
-export type SubscribeRequest = Request<Partial<DataPacket<ChannelOptions>>, void>;
-export type PublishRequest<T> = Request<Partial<DataPacket<T>>, void>;
-export declare class UnsubscribeRequest extends Request<string, void> {
+export type InvokeRequest<T, U = any> = RequestWithResponse<T, U>;
+export type SubscribeRequest = Request<Partial<DataPacket<ChannelOptions>>>;
+export type PublishRequest<T> = Request<Partial<DataPacket<T>>>;
+export declare class UnsubscribeRequest extends Request<string> {
     constructor(socket: RequestSocket, id: number, procedureName: '#unsubscribe', data: string);
 }
 export interface AuthenticateData {
     isAuthenticated: boolean;
     authError: Error | null;
 }
-export declare class AuthenticateRequest extends Request<string, AuthenticateData> {
+export declare class AuthenticateRequest extends RequestWithResponse<string, AuthenticateData> {
     constructor(socket: RequestSocket, id: number, procedureName: '#authenticate', data: string);
 }
-export declare function isSubscribeRequest(request: Request<unknown>): request is SubscribeRequest;
-export declare function isPublishRequest<T>(request: Request<unknown>): request is PublishRequest<T>;

package/request.js

@@ -1,5 +1,5 @@
-import { Request } from "@socket-mesh/request";
-export class HandshakeRequest extends Request {
+import { Request, RequestWithResponse } from "@socket-mesh/request";
+export class HandshakeRequest extends RequestWithResponse {
     constructor(socket, id, procedureName, data) {
         super(socket, id, procedureName, data);
     }
@@ -9,14 +9,8 @@ export class UnsubscribeRequest extends Request {
         super(socket, id, procedureName, data);
     }
 }
-export class AuthenticateRequest extends Request {
+export class AuthenticateRequest extends RequestWithResponse {
     constructor(socket, id, procedureName, data) {
         super(socket, id, procedureName, data);
     }
 }
-export function isSubscribeRequest(request) {
-    return request.procedure === '#subscribe';
-}
-export function isPublishRequest(request) {
-    return request.procedure === '#publish';
-}

package/server-options.d.ts

@@ -3,13 +3,10 @@ import { CodecEngine } from "@socket-mesh/formatter";
 import ws from "ws";
 import jwt from "jsonwebtoken";
 import { Server as HttpServer } from 'http';
-import { AuthEngine } from "@socket-mesh/server-auth";
+import { AuthEngine } from "./auth-engine";
 export type ProtocolVersions = 1 | 2;
 export interface ServerOptions {
     httpServer?: HttpServer;
-    wsEngine?: string | {
-        Server: ws.Server;
-    };
     wsEngineServerOptions?: ws.ServerOptions;
     authKey?: jwt.Secret;
     perMessageDeflate?: boolean | ws.PerMessageDeflateOptions;
@@ -31,9 +28,9 @@ export interface ServerOptions {
     batchOnHandshake?: boolean;
     batchOnHandshakeDuration?: number;
     batchInterval?: number;
-    socketStreamCleanupMode?: 'kill' | 'close';
+    socketStreamCleanupMode?: 'kill' | 'close' | 'none';
     authVerifyAlgorithms?: jwt.Algorithm[];
-    authEngine?: AuthEngine;
+    authEngine?: AuthEngine<any>;
     codecEngine?: CodecEngine;
     cloneData?: boolean;
     strictHandshake?: boolean;

package/server.d.ts

@@ -1,14 +1,14 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { AuthEngine } from "@socket-mesh/server-auth";
+import { AuthEngine } from "./auth-engine";
 import { CodecEngine } from "@socket-mesh/formatter";
 import { Broker, Packet } from "@socket-mesh/simple-broker";
 import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
 import { MiddlewareType } from "./middleware-type";
 import { MiddlewareStream } from "./middleware-stream";
-import { ActionAuthenticate, ActionHandshakeSC, ActionHandshakeWS, ActionInvoke, ActionMessage, ActionPublishIn, ActionPublishOut, ActionResult, ActionSubscribe, ActionTransmit, AuthInfo, MiddlewareAction } from "./action";
+import { ActionAuthenticate, ActionHandshakeSC, ActionHandshakeWS, ActionMessage, ActionPublishOut, ActionResult, ActionSubscribe, AuthInfo, HandshakeAction, InboundAction, MiddlewareAction } from "./action";
 import { ProtocolVersions, ServerOptions } from "./server-options";
-import ws from "ws";
+import { PerMessageDeflateOptions, WebSocketServer } from 'ws';
 import jwt from "jsonwebtoken";
 import { Server as HttpServer } from 'http';
 import { ServerSocket } from "./serversocket";
@@ -21,7 +21,7 @@ export type ServerEvent<T, U extends ServerSocketEvents | {}> = {
 type ServerEvents<T> = ServerEvent<T, Connected> | ServerEvent<T, ConnectAborted> | ServerEvent<T, Disconnected> | ServerEvent<T, Closed> | {} | ServerEvent<T, BadAuthToken> | ServerEvent<T, Authenticated> | ServerEvent<T, AuthStateChanged> | ServerEvent<T, Deauthenticated> | ServerEvent<T, {}> | ErrorOccurred | WarningOccurred | ServerEvent<T, Subscribed> | ServerEvent<T, Unsubscribed>;
 export declare class Server<T> extends AsyncStreamEmitter<ServerEvents<T>> {
     allowClientPublish: boolean;
-    auth: AuthEngine;
+    auth: AuthEngine<T>;
     clientsCount: number;
     codec: CodecEngine;
     defaultVerificationOptions: jwt.VerifyOptions;
@@ -34,7 +34,7 @@ export declare class Server<T> extends AsyncStreamEmitter<ServerEvents<T>> {
     handshakeTimeout: number;
     options: ServerOptions;
     path: string;
-    perMessageDeflate?: boolean | ws.PerMessageDeflateOptions;
+    perMessageDeflate?: boolean | PerMessageDeflateOptions;
     pingInterval: number;
     pingTimeout: number;
     pingTimeoutDisabled: boolean;
@@ -52,12 +52,12 @@ export declare class Server<T> extends AsyncStreamEmitter<ServerEvents<T>> {
     };
     readonly brokerEngine: Broker<T>;
     readonly exchange: Client<Packet<T>>;
-    readonly wsServer: ws.Server;
+    readonly wsServer: WebSocketServer;
     private readonly _allowAllOrigins;
     private readonly _path;
     private readonly _middleware;
     constructor(options: ServerOptions);
-    setAuthEngine(authEngine: AuthEngine): void;
+    setAuthEngine(authEngine: AuthEngine<T>): void;
     setCodecEngine(codecEngine: CodecEngine): void;
     emitError(error: Error): void;
     emitWarning(warning: Error): void;
@@ -94,20 +94,20 @@ export declare class Server<T> extends AsyncStreamEmitter<ServerEvents<T>> {
     close(keepSocketsOpen?: boolean): Promise<void>;
     getPath(): string;
     generateId(): string;
-    setMiddleware(type: MiddlewareType.MIDDLEWARE_HANDSHAKE, middleware: (stream: MiddlewareStream<void>) => void): void;
-    setMiddleware(type: MiddlewareType.MIDDLEWARE_INBOUND_RAW, middleware: (stream: MiddlewareStream<string | ArrayBuffer | Buffer[]>) => void): void;
-    setMiddleware(type: MiddlewareType.MIDDLEWARE_INBOUND, middleware: (stream: MiddlewareStream<ChannelOptions | T | void>) => void): void;
-    setMiddleware(type: MiddlewareType.MIDDLEWARE_OUTBOUND, middleware: (stream: MiddlewareStream<T>) => void): void;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_HANDSHAKE, middleware: (stream: MiddlewareStream<HandshakeAction<T>>) => void): void;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_INBOUND_RAW, middleware: (stream: MiddlewareStream<ActionMessage<T>>) => void): void;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_INBOUND, middleware: (stream: MiddlewareStream<InboundAction<T>>) => void): void;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_OUTBOUND, middleware: (stream: MiddlewareStream<ActionPublishOut<T>>) => void): void;
     removeMiddleware(type: MiddlewareType): void;
     hasMiddleware(type: MiddlewareType): boolean;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<void | T | ChannelOptions>, action: ActionSubscribe<T> | ActionTransmit<T> | ActionInvoke<T> | ActionPublishIn<T>, socket?: ServerSocket<T>): Promise<ActionResult<T>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<void | T | ChannelOptions>, action: ActionAuthenticate<T>, socket?: ServerSocket<T>): Promise<ActionResult<void>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<T>, action: ActionPublishOut<T>, socket?: ServerSocket<T>): Promise<ActionResult<T>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<ChannelOptions>, action: ActionSubscribe<T>, socket?: ServerSocket<T>): Promise<ActionResult<ChannelOptions>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<void>, action: ActionHandshakeWS, socket?: ServerSocket<T>): Promise<ActionResult<void>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<void>, action: ActionHandshakeSC<T>, socket?: ServerSocket<T>): Promise<ActionResult<void>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<string | ArrayBuffer | Buffer[]>, action: ActionMessage<T>, socket?: ServerSocket<T>): Promise<ActionResult<string | ArrayBuffer | Buffer[]>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<T | ChannelOptions | AuthInfo | string | ArrayBuffer | Buffer[] | void>, action: MiddlewareAction<T>, socket?: ServerSocket<T>): Promise<ActionResult<T | ChannelOptions | AuthInfo | string | ArrayBuffer | Buffer[] | void>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<InboundAction<T>>, action: InboundAction<T>, socket?: ServerSocket<T>): Promise<ActionResult<T>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionAuthenticate<T>>, action: ActionAuthenticate<T>, socket?: ServerSocket<T>): Promise<ActionResult<void>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionPublishOut<T>>, action: ActionPublishOut<T>, socket?: ServerSocket<T>): Promise<ActionResult<T>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionSubscribe<T>>, action: ActionSubscribe<T>, socket?: ServerSocket<T>): Promise<ActionResult<ChannelOptions>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionHandshakeWS>, action: ActionHandshakeWS, socket?: ServerSocket<T>): Promise<ActionResult<void>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionHandshakeSC<T>>, action: ActionHandshakeSC<T>, socket?: ServerSocket<T>): Promise<ActionResult<void>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionMessage<T>>, action: ActionMessage<T>, socket?: ServerSocket<T>): Promise<ActionResult<string | ArrayBuffer | Buffer[]>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<MiddlewareAction<T>>, action: MiddlewareAction<T>, socket?: ServerSocket<T>): Promise<ActionResult<T | ChannelOptions | AuthInfo | string | ArrayBuffer | Buffer[] | void>>;
     private _verifyHandshake;
 }
 export {};

package/server.js

@@ -14,7 +14,7 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
-import { AuthEngine } from "@socket-mesh/server-auth";
+import { AuthEngine } from "./auth-engine";
 import formatter from "@socket-mesh/formatter";
 import { SimpleBroker } from "@socket-mesh/simple-broker";
 import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
@@ -22,6 +22,7 @@ import { InvalidArgumentsError, InvalidOptionsError, InvalidActionError, ServerP
 import { MiddlewareType } from "./middleware-type";
 import { MiddlewareStream } from "./middleware-stream";
 import { ActionHandshakeWS } from "./action";
+import { WebSocketServer } from 'ws';
 import base64id from 'base64id';
 import { ServerSocket } from "./serversocket";
 import url from "url";
@@ -151,12 +152,14 @@ export class Server extends AsyncStreamEmitter {
                 this.emit('ready', {});
             }))();
         }
-        let wsEngine = typeof opts.wsEngine === 'string' ? require(opts.wsEngine) : opts.wsEngine;
-        if (!wsEngine || !wsEngine.Server) {
-            throw new InvalidOptionsError('The wsEngine option must be a path or module name which points ' +
-                'to a valid WebSocket engine module with a compatible interface');
-        }
-        let WSServer = wsEngine.Server;
+        //		let wsEngine = typeof opts.wsEngine === 'string' ? require(opts.wsEngine) : opts.wsEngine;
+        //		if (!wsEngine || !wsEngine.Server) {
+        //			throw new InvalidOptionsError(
+        //				'The wsEngine option must be a path or module name which points ' +
+        //				'to a valid WebSocket engine module with a compatible interface'
+        //			);
+        //		}
+        //		let WSServer = wsEngine.Server;
         if (opts.authPrivateKey != null || opts.authPublicKey != null) {
             if (opts.authPrivateKey == null) {
                 throw new InvalidOptionsError('The authPrivateKey option must be specified if authPublicKey is specified');
@@ -207,7 +210,7 @@ export class Server extends AsyncStreamEmitter {
         this.clientsCount = 0;
         this.pendingClients = {};
         this.pendingClientsCount = 0;
-        let wsServerOptions = opts.wsEngineServerOptions || {};
+        const wsServerOptions = opts.wsEngineServerOptions || {};
         wsServerOptions.server = this.httpServer;
         wsServerOptions.verifyClient = this._verifyHandshake.bind(this);
         if (wsServerOptions.path == null && this._path != null) {
@@ -225,7 +228,7 @@ export class Server extends AsyncStreamEmitter {
         if (wsServerOptions.clientTracking == null) {
             wsServerOptions.clientTracking = false;
         }
-        this.wsServer = new WSServer(wsServerOptions);
+        this.wsServer = new WebSocketServer(wsServerOptions);
         this.wsServer.on('error', this._handleServerError.bind(this));
         this.wsServer.on('connection', this._handleSocketConnection.bind(this));
     }

package/serversocket-procedure.d.ts

@@ -0,0 +1,13 @@
+import { DemuxedConsumableStream, StreamDemux, StreamDemuxWrapper } from "@socket-mesh/stream-demux";
+import { AuthenticateRequest, HandshakeRequest, InboundRequest, InvokeRequest, PublishRequest, SubscribeRequest, UnsubscribeRequest } from "./request";
+import { Request } from "@socket-mesh/request";
+export declare class ServerSocketProcedure<T> extends StreamDemuxWrapper<InboundRequest<T>> {
+    constructor(stream: StreamDemux<InboundRequest<T>>);
+    listen(name: '#handshake'): DemuxedConsumableStream<HandshakeRequest>;
+    listen(name: '#authenticate'): DemuxedConsumableStream<AuthenticateRequest>;
+    listen(name: '#subscribe'): DemuxedConsumableStream<SubscribeRequest>;
+    listen(name: '#unsubscribe'): DemuxedConsumableStream<UnsubscribeRequest>;
+    listen(name: '#publish'): DemuxedConsumableStream<PublishRequest<T>>;
+    listen<U extends T>(name: string): DemuxedConsumableStream<Request<U>>;
+    listen<U extends T, V>(name: string): DemuxedConsumableStream<InvokeRequest<U, V>>;
+}

package/serversocket-procedure.js

@@ -0,0 +1,9 @@
+import { StreamDemuxWrapper } from "@socket-mesh/stream-demux";
+export class ServerSocketProcedure extends StreamDemuxWrapper {
+    constructor(stream) {
+        super(stream);
+    }
+    listen(name) {
+        return super.listen(name);
+    }
+}

package/serversocket.d.ts

@@ -2,20 +2,21 @@
 /// <reference types="node" />
 import { ChannelOptions } from "@socket-mesh/channel";
 import { AuthState, AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { AuthTokenOptions } from "@socket-mesh/server-auth";
+import { AuthTokenOptions } from "./auth-engine";
 import { WritableConsumableStream } from "@socket-mesh/writable-consumable-stream";
 import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
 import { DemuxedConsumableStream, StreamDemuxWrapper } from "@socket-mesh/stream-demux";
+import { ResponsePacketError } from "@socket-mesh/request";
 import { IncomingMessage } from 'http';
 import { SocketState } from "./socket-state";
-import { AuthInfo } from "./action";
+import { ActionMessage, ActionPublishOut, AuthInfo, HandshakeAction, InboundAction } from "./action";
 import { AuthStateChanged, AuthTokenSigned, Authenticated, BadAuthToken, Closed, ConnectAborted, Connected, Deauthenticated, Disconnected, ErrorOccurred, RawMessage, ServerSocketEvents, Subscribed, Unsubscribed } from './events';
 import { MiddlewareStream } from './middleware-stream';
 import { ProtocolVersions } from './server-options';
 import ws from "ws";
 import { Server } from "./server";
 import { OutboundPacket, OutboundPacketOptions } from './outbound-packet';
-import { InboundRequest } from './request';
+import { ServerSocketProcedure } from './serversocket-procedure';
 export type WebSocket = ws.WebSocket & {
     bytesReceived: number;
     upgradeReq: IncomingMessage;
@@ -53,10 +54,10 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
     readonly inboundMessageStream: WritableConsumableStream<string | ArrayBuffer | Buffer[]>;
     readonly outboundPacketStream: WritableConsumableStream<OutboundPacket<T>>;
     readonly server: Server<T>;
-    readonly middlewareHandshakeStream: MiddlewareStream<void>;
-    readonly middlewareInboundRawStream: MiddlewareStream<string | ArrayBuffer | Buffer[]>;
-    readonly middlewareInboundStream: MiddlewareStream<ChannelOptions | T | void>;
-    readonly middlewareOutboundStream: MiddlewareStream<T>;
+    readonly middlewareHandshakeStream: MiddlewareStream<HandshakeAction<T>>;
+    readonly middlewareInboundRawStream: MiddlewareStream<ActionMessage<T>>;
+    readonly middlewareInboundStream: MiddlewareStream<InboundAction<T>>;
+    readonly middlewareOutboundStream: MiddlewareStream<ActionPublishOut<T>>;
     readonly remoteAddress?: string;
     readonly remoteFamily?: string;
     readonly remotePort?: number;
@@ -65,7 +66,7 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
     signedAuthToken: SignedAuthToken | null;
     state: SocketState;
     readonly receiver: StreamDemuxWrapper<string | void | T | ArrayBuffer | Buffer[] | AuthInfo | ChannelOptions>;
-    readonly procedure: StreamDemuxWrapper<InboundRequest<T>>;
+    readonly procedure: ServerSocketProcedure<T>;
     private _cid;
     private _handshakeTimeoutRef;
     private _pingIntervalTicker;
@@ -78,6 +79,7 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
     private readonly _sendPing;
     constructor(id: string, server: Server<T>, socket: WebSocket, protocolVersion: ProtocolVersions);
     getBackpressure(): number;
+    get exchange(): import("@socket-mesh/channel").Client<import("@socket-mesh/simple-broker/packet").Packet<T>>;
     getInboundBackpressure(): number;
     getOutboundBackpressure(): number;
     private _startBatchOnHandshake;
@@ -111,7 +113,7 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
     killIO(): void;
     killAllStreams(): void;
     private _destroy;
-    disconnect(code: number, reason?: string): void;
+    disconnect(code?: number, reason?: string): void;
     terminate(): void;
     send(data: string, options?: SendOptions): void;
     decode(message: string): any;
@@ -126,7 +128,7 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
     private _cancelBatching;
     cancelBatching(): void;
     serializeObject(object: any): string | null;
-    sendObject(object: EventObject): void;
+    sendObject(object: EventObject | ResponsePacketError): void;
     private _handleOutboundPacketStream;
     private _transmit;
     transmit(event: string, data: any, options?: OutboundPacketOptions): void;

package/serversocket.js

@@ -19,7 +19,7 @@ import { AuthState } from "@socket-mesh/auth";
 import { WritableConsumableStream } from "@socket-mesh/writable-consumable-stream";
 import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
 import { StreamDemux, StreamDemuxWrapper } from "@socket-mesh/stream-demux";
-import { Request } from "@socket-mesh/request";
+import { Request, RequestWithResponse, createErrorResponse } from "@socket-mesh/request";
 import { dehydrateError, hydrateError, socketProtocolIgnoreStatuses, socketProtocolErrorStatuses, InvalidArgumentsError, SocketProtocolError, TimeoutError, BadConnectionError, InvalidActionError, AuthError, AuthTokenExpiredError, AuthTokenInvalidError, AuthTokenNotBeforeError, AuthTokenError, BrokerError } from "@socket-mesh/errors";
 import { SocketState } from "./socket-state";
 import { MiddlewareType } from "./middleware-type";
@@ -27,7 +27,8 @@ import { ActionAuthenticate, ActionHandshakeSC, ActionInvoke, ActionMessage, Act
 import { MiddlewareStream } from './middleware-stream';
 import { isAuthenticatePacket, isHandshakePacket, isPublishPacket, isRemoveAuthTokenPacket, isSubscribePacket, isUnsubscribePacket } from './inbound-packet';
 import { isPublishOutPacket } from './outbound-packet';
-import { AuthenticateRequest, HandshakeRequest, UnsubscribeRequest, isPublishRequest, isSubscribeRequest } from './request';
+import { AuthenticateRequest, HandshakeRequest, UnsubscribeRequest } from './request';
+import { ServerSocketProcedure } from './serversocket-procedure';
 const HANDSHAKE_REJECTION_STATUS_CODE = 4008;
 export class ServerSocket extends AsyncStreamEmitter {
     constructor(id, server, socket, protocolVersion) {
@@ -41,7 +42,7 @@ export class ServerSocket extends AsyncStreamEmitter {
         this._receiverDemux = new StreamDemux();
         this.receiver = new StreamDemuxWrapper(this._receiverDemux);
         this._procedureDemux = new StreamDemux();
-        this.procedure = new StreamDemuxWrapper(this._procedureDemux);
+        this.procedure = new ServerSocketProcedure(this._procedureDemux);
         this.request = this.socket.upgradeReq;
         this.inboundReceivedMessageCount = 0;
         this.inboundProcessedMessageCount = 0;
@@ -141,15 +142,15 @@ export class ServerSocket extends AsyncStreamEmitter {
     getBackpressure() {
         return Math.max(this.getInboundBackpressure(), this.getOutboundBackpressure(), this.getListenerBackpressure(), this.receiver.getBackpressure(), this.procedure.getBackpressure());
     }
-    ;
+    get exchange() {
+        return this.server.exchange;
+    }
     getInboundBackpressure() {
         return this.inboundReceivedMessageCount - this.inboundProcessedMessageCount;
     }
-    ;
     getOutboundBackpressure() {
         return this.outboundPreparedMessageCount - this.outboundSentMessageCount;
     }
-    ;
     _startBatchOnHandshake() {
         this._startBatching();
         setTimeout(() => {
@@ -158,7 +159,6 @@ export class ServerSocket extends AsyncStreamEmitter {
             }
         }, this.batchOnHandshakeDuration);
     }
-    ;
     _handleInboundMessageStream(pongMessage) {
         var _a, e_1, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
@@ -221,11 +221,9 @@ export class ServerSocket extends AsyncStreamEmitter {
             }
         });
     }
-    ;
     _handleHandshakeTimeout() {
         this.disconnect(4005);
     }
-    ;
     _processHandshakeRequest(request) {
         return __awaiter(this, void 0, void 0, function* () {
             let data = request.data || { authToken: '' };
@@ -363,7 +361,6 @@ export class ServerSocket extends AsyncStreamEmitter {
             });
         });
     }
-    ;
     _processSubscribeRequest(request) {
         return __awaiter(this, void 0, void 0, function* () {
             let subscriptionOptions = Object.assign({}, request.data);
@@ -393,7 +390,6 @@ export class ServerSocket extends AsyncStreamEmitter {
         const channels = Object.keys(this.channelSubscriptions);
         return Promise.all(channels.map((channel) => this._unsubscribe(channel)));
     }
-    ;
     _unsubscribe(channel) {
         return __awaiter(this, void 0, void 0, function* () {
             if (typeof channel !== 'string') {
@@ -417,7 +413,6 @@ export class ServerSocket extends AsyncStreamEmitter {
             }
         });
     }
-    ;
     _processUnsubscribePacket(packet) {
         return __awaiter(this, void 0, void 0, function* () {
             let channel = packet.data;
@@ -430,7 +425,6 @@ export class ServerSocket extends AsyncStreamEmitter {
             }
         });
     }
-    ;
     _processUnsubscribeRequest(request) {
         return __awaiter(this, void 0, void 0, function* () {
             const channel = request.data;
@@ -548,31 +542,30 @@ export class ServerSocket extends AsyncStreamEmitter {
                 }
                 let newData;
                 if (isRPC) {
-                    let request = new Request(this, packet.cid, packet.event, packet.data);
                     try {
                         let { data } = yield this.server._processMiddlewareAction(this.middlewareInboundStream, action, this);
                         newData = data;
                     }
                     catch (error) {
-                        request.error(error);
+                        this.sendObject(createErrorResponse(packet.cid, error));
                         return;
                     }
-                    if (isSubscribeRequest(request)) {
+                    let request;
+                    if (isSubscribePacket(packet) || isPublishPacket(packet)) {
+                        request = new Request(this, packet.cid, packet.event, packet.data);
                         if (!request.data) {
                             request.data = {};
                         }
                         request.data.data = newData;
-                        yield this._processSubscribeRequest(request);
-                    }
-                    else if (isPublishRequest(request)) {
-                        if (!request.data) {
-                            request.data = {};
+                        if (isSubscribePacket(packet)) {
+                            yield this._processSubscribeRequest(request);
+                        }
+                        else {
+                            yield this._processInboundPublishRequest(request);
                         }
-                        request.data.data = newData;
-                        yield this._processInboundPublishRequest(request);
                     }
                     else {
-                        request.data = newData;
+                        request = new RequestWithResponse(this, packet.cid, packet.event, newData);
                     }
                     this._procedureDemux.write(request.procedure, request);
                     return;
@@ -614,7 +607,6 @@ export class ServerSocket extends AsyncStreamEmitter {
             this.emit('raw', { message });
         });
     }
-    ;
     _resetPongTimeout() {
         if (this.server.pingTimeoutDisabled) {
             return;
@@ -850,7 +842,6 @@ export class ServerSocket extends AsyncStreamEmitter {
         this.isBatching = false;
         this._cancelBatching();
     }
-    ;
     serializeObject(object) {
         let str;
         try {
@@ -862,7 +853,6 @@ export class ServerSocket extends AsyncStreamEmitter {
         }
         return str;
     }
-    ;
     sendObject(object) {
         if (this.isBufferingBatch) {
             this._batchBuffer.push(object);
@@ -1236,7 +1226,7 @@ export class ServerSocket extends AsyncStreamEmitter {
     }
     _validateAuthToken(signedAuthToken) {
         return __awaiter(this, void 0, void 0, function* () {
-            const verificationOptions = Object.assign({}, this.server.defaultVerificationOptions);
+            const verificationOptions = Object.assign({ socket: this }, this.server.defaultVerificationOptions);
             let authToken;
             try {
                 authToken = yield this.server.auth.verifyToken(signedAuthToken, this.server.verificationKey, verificationOptions);