@socket-mesh/server 17.3.6 → 18.0.0

package/server.d.ts

@@ -1,25 +1,25 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { AuthEngine } from "@socket-mesh/server-auth";
+import { AuthEngine } from "./auth-engine.js";
 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 { ProtocolVersions, ServerOptions } from "./server-options";
-import ws from "ws";
+import { MiddlewareType } from "./middleware-type.js";
+import { MiddlewareStream } from "./middleware-stream.js";
+import { ActionAuthenticate, ActionHandshakeSC, ActionHandshakeWS, ActionMessage, ActionPublishOut, ActionResult, ActionSubscribe, AuthInfo, HandshakeAction, InboundAction, MiddlewareAction } from "./action.js";
+import { ProtocolVersions, ServerOptions } from "./server-options.js";
+import { PerMessageDeflateOptions, WebSocketServer } from 'ws';
 import jwt from "jsonwebtoken";
 import { Server as HttpServer } from 'http';
-import { ServerSocket } from "./serversocket";
+import { ServerSocket } from "./serversocket.js";
 import { ChannelOptions, Client } from "@socket-mesh/channel";
-import { AuthStateChanged, Authenticated, BadAuthToken, Closed, ConnectAborted, Connected, Deauthenticated, Disconnected, ErrorOccurred, ServerSocketEvents, Subscribed, Unsubscribed, WarningOccurred } from "./events";
+import { AuthStateChanged, Authenticated, BadAuthToken, Closed, ConnectAborted, Connected, Deauthenticated, Disconnected, ErrorOccurred, ServerSocketEvents, Subscribed, Unsubscribed, WarningOccurred } from "./events.js";
 import { DemuxedConsumableStream } from "@socket-mesh/stream-demux";
-export type ServerEvent<T, U extends ServerSocketEvents | {}> = {
-    socket: ServerSocket<T>;
-} & U;
-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>> {
+export type ServerEvent<T extends ServerSocketEvents | {}> = {
+    socket: ServerSocket;
+} & T;
+type ServerEvents = ServerEvent<Connected> | ServerEvent<ConnectAborted> | ServerEvent<Disconnected> | ServerEvent<Closed> | {} | ServerEvent<BadAuthToken> | ServerEvent<Authenticated> | ServerEvent<AuthStateChanged> | ServerEvent<Deauthenticated> | ServerEvent<{}> | ErrorOccurred | WarningOccurred | ServerEvent<Subscribed> | ServerEvent<Unsubscribed>;
+export declare class Server extends AsyncStreamEmitter<ServerEvents> {
     allowClientPublish: boolean;
     auth: AuthEngine;
     clientsCount: number;
@@ -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;
@@ -45,14 +45,14 @@ export declare class Server<T> extends AsyncStreamEmitter<ServerEvents<T>> {
     socketChannelLimit?: number;
     verificationKey: jwt.Secret;
     readonly clients: {
-        [id: string]: ServerSocket<T>;
+        [id: string]: ServerSocket;
     };
     readonly pendingClients: {
-        [id: string]: ServerSocket<T>;
+        [id: string]: ServerSocket;
     };
-    readonly brokerEngine: Broker<T>;
-    readonly exchange: Client<Packet<T>>;
-    readonly wsServer: ws.Server;
+    readonly brokerEngine: Broker<any>;
+    readonly exchange: Client<Packet<any>>;
+    readonly wsServer: WebSocketServer;
     private readonly _allowAllOrigins;
     private readonly _path;
     private readonly _middleware;
@@ -63,51 +63,51 @@ export declare class Server<T> extends AsyncStreamEmitter<ServerEvents<T>> {
     emitWarning(warning: Error): void;
     private _handleServerError;
     private _handleSocketConnection;
-    emit(eventName: 'connection', data: ServerEvent<T, Connected>): void;
-    emit(eventName: 'connectionAbort', data: ServerEvent<T, ConnectAborted>): void;
-    emit(eventName: 'disconnection', data: ServerEvent<T, Disconnected>): void;
-    emit(eventName: 'closure', data: ServerEvent<T, Closed>): void;
+    emit(eventName: 'connection', data: ServerEvent<Connected>): void;
+    emit(eventName: 'connectionAbort', data: ServerEvent<ConnectAborted>): void;
+    emit(eventName: 'disconnection', data: ServerEvent<Disconnected>): void;
+    emit(eventName: 'closure', data: ServerEvent<Closed>): void;
     emit(eventName: 'ready', data: {}): void;
-    emit(eventName: 'authentication', data: ServerEvent<T, Authenticated>): void;
-    emit(eventName: 'badSocketAuthToken', data: ServerEvent<T, BadAuthToken>): void;
+    emit(eventName: 'authentication', data: ServerEvent<Authenticated>): void;
+    emit(eventName: 'badSocketAuthToken', data: ServerEvent<BadAuthToken>): void;
     emit(eventName: 'error', data: ErrorOccurred): void;
-    emit(eventName: 'handshake', data: ServerEvent<T, {}>): void;
+    emit(eventName: 'handshake', data: ServerEvent<{}>): void;
     emit(eventName: 'warning', data: WarningOccurred): void;
-    emit(eventName: 'subscription', data: ServerEvent<T, Subscribed>): void;
-    emit(eventName: 'unsubscription', data: ServerEvent<T, Unsubscribed>): void;
-    emit(eventName: 'authenticationStateChange', data: ServerEvent<T, AuthStateChanged>): void;
-    emit(eventName: 'deauthentication', data: ServerEvent<T, Deauthenticated>): void;
-    listen(eventName: 'connection'): DemuxedConsumableStream<ServerEvent<T, Connected>>;
-    listen(eventName: 'connectionAbort'): DemuxedConsumableStream<ServerEvent<T, ConnectAborted>>;
-    listen(eventName: 'disconnection'): DemuxedConsumableStream<ServerEvent<T, Disconnected>>;
-    listen(eventName: 'closure'): DemuxedConsumableStream<ServerEvent<T, Closed>>;
+    emit(eventName: 'subscription', data: ServerEvent<Subscribed>): void;
+    emit(eventName: 'unsubscription', data: ServerEvent<Unsubscribed>): void;
+    emit(eventName: 'authenticationStateChange', data: ServerEvent<AuthStateChanged>): void;
+    emit(eventName: 'deauthentication', data: ServerEvent<Deauthenticated>): void;
+    listen(eventName: 'connection'): DemuxedConsumableStream<ServerEvent<Connected>>;
+    listen(eventName: 'connectionAbort'): DemuxedConsumableStream<ServerEvent<ConnectAborted>>;
+    listen(eventName: 'disconnection'): DemuxedConsumableStream<ServerEvent<Disconnected>>;
+    listen(eventName: 'closure'): DemuxedConsumableStream<ServerEvent<Closed>>;
     listen(eventName: 'ready'): DemuxedConsumableStream<{}>;
-    listen(eventName: 'authentication'): DemuxedConsumableStream<ServerEvent<T, Authenticated>>;
-    listen(eventName: 'badSocketAuthToken'): DemuxedConsumableStream<ServerEvent<T, BadAuthToken>>;
+    listen(eventName: 'authentication'): DemuxedConsumableStream<ServerEvent<Authenticated>>;
+    listen(eventName: 'badSocketAuthToken'): DemuxedConsumableStream<ServerEvent<BadAuthToken>>;
     listen(eventName: 'error'): DemuxedConsumableStream<ErrorOccurred>;
-    listen(eventName: 'handshake'): DemuxedConsumableStream<ServerEvent<T, {}>>;
+    listen(eventName: 'handshake'): DemuxedConsumableStream<ServerEvent<{}>>;
     listen(eventName: 'warning'): DemuxedConsumableStream<WarningOccurred>;
-    listen(eventName: 'subscription'): DemuxedConsumableStream<ServerEvent<T, Subscribed>>;
-    listen(eventName: 'unsubscription'): DemuxedConsumableStream<ServerEvent<T, Unsubscribed>>;
-    listen(eventName: 'authenticationStateChange'): DemuxedConsumableStream<ServerEvent<T, AuthStateChanged>>;
-    listen(eventName: 'deauthentication'): DemuxedConsumableStream<ServerEvent<T, Deauthenticated>>;
+    listen(eventName: 'subscription'): DemuxedConsumableStream<ServerEvent<Subscribed>>;
+    listen(eventName: 'unsubscription'): DemuxedConsumableStream<ServerEvent<Unsubscribed>>;
+    listen(eventName: 'authenticationStateChange'): DemuxedConsumableStream<ServerEvent<AuthStateChanged>>;
+    listen(eventName: 'deauthentication'): DemuxedConsumableStream<ServerEvent<Deauthenticated>>;
     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>) => void): void;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_INBOUND_RAW, middleware: (stream: MiddlewareStream<ActionMessage>) => void): void;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_INBOUND, middleware: (stream: MiddlewareStream<InboundAction>) => void): void;
+    setMiddleware(type: MiddlewareType.MIDDLEWARE_OUTBOUND, middleware: (stream: MiddlewareStream<ActionPublishOut>) => 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>, action: InboundAction, socket?: ServerSocket): Promise<ActionResult<any>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionAuthenticate>, action: ActionAuthenticate, socket?: ServerSocket): Promise<ActionResult<void>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionPublishOut>, action: ActionPublishOut, socket?: ServerSocket): Promise<ActionResult<any>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionSubscribe>, action: ActionSubscribe, socket?: ServerSocket): Promise<ActionResult<ChannelOptions>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionHandshakeWS>, action: ActionHandshakeWS, socket?: ServerSocket): Promise<ActionResult<void>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionHandshakeSC>, action: ActionHandshakeSC, socket?: ServerSocket): Promise<ActionResult<void>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionMessage>, action: ActionMessage, socket?: ServerSocket): Promise<ActionResult<string | ArrayBuffer | Buffer[]>>;
+    _processMiddlewareAction(middlewareStream: MiddlewareStream<MiddlewareAction>, action: MiddlewareAction, socket?: ServerSocket): Promise<ActionResult<any | ChannelOptions | AuthInfo | string | ArrayBuffer | Buffer[] | void>>;
     private _verifyHandshake;
 }
 export {};

package/server.js

@@ -1,80 +1,62 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    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.js";
 import formatter from "@socket-mesh/formatter";
 import { SimpleBroker } from "@socket-mesh/simple-broker";
 import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
 import { InvalidArgumentsError, InvalidOptionsError, InvalidActionError, ServerProtocolError, SilentMiddlewareBlockedError } from "@socket-mesh/errors";
-import { MiddlewareType } from "./middleware-type";
-import { MiddlewareStream } from "./middleware-stream";
-import { ActionHandshakeWS } from "./action";
-import ws from "ws";
+import { MiddlewareType } from "./middleware-type.js";
+import { MiddlewareStream } from "./middleware-stream.js";
+import { ActionHandshakeWS } from "./action.js";
+import { WebSocketServer } from 'ws';
 import base64id from 'base64id';
-import { ServerSocket } from "./serversocket";
+import { ServerSocket } from "./serversocket.js";
 import url from "url";
 import crypto from "crypto";
 export class Server extends AsyncStreamEmitter {
     constructor(options) {
         super();
-        this._verifyHandshake = function (info, callback) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let req = info.req;
-                let origin = info.origin;
-                if (origin === 'null' || origin == null) {
-                    origin = '*';
-                }
-                let ok = false;
-                if (this._allowAllOrigins) {
-                    ok = true;
-                }
-                else {
-                    try {
-                        let parts = url.parse(origin);
-                        parts.port = parts.port || (parts.protocol === 'https:' ? '443' : '80');
-                        ok = !!(~this.origins.indexOf(parts.hostname + ':' + parts.port) ||
-                            ~this.origins.indexOf(parts.hostname + ':*') ||
-                            ~this.origins.indexOf('*:' + parts.port));
-                    }
-                    catch (e) { }
-                }
-                const middlewareHandshakeStream = new MiddlewareStream(MiddlewareType.MIDDLEWARE_HANDSHAKE);
-                req['handshakeStream'] = middlewareHandshakeStream;
-                const handshakeMiddleware = this._middleware[MiddlewareType.MIDDLEWARE_HANDSHAKE];
-                if (handshakeMiddleware) {
-                    handshakeMiddleware(middlewareHandshakeStream);
-                }
-                const action = new ActionHandshakeWS(req);
+        this._verifyHandshake = async function (info, callback) {
+            let req = info.req;
+            let origin = info.origin;
+            if (typeof origin !== 'string' || origin === 'null') {
+                origin = '*';
+            }
+            let ok = false;
+            if (this._allowAllOrigins) {
+                ok = true;
+            }
+            else {
                 try {
-                    yield this._processMiddlewareAction(middlewareHandshakeStream, action);
-                }
-                catch (error) {
-                    middlewareHandshakeStream.close();
-                    callback(false, 401, typeof error === 'string' ? error : error.message);
-                    return;
-                }
-                if (ok) {
-                    callback(true);
-                    return;
+                    let parts = url.parse(origin);
+                    parts.port = parts.port || (parts.protocol === 'https:' ? '443' : '80');
+                    ok = !!(~this.origins.indexOf(parts.hostname + ':' + parts.port) ||
+                        ~this.origins.indexOf(parts.hostname + ':*') ||
+                        ~this.origins.indexOf('*:' + parts.port));
                 }
-                const error = new ServerProtocolError(`Failed to authorize socket handshake - Invalid origin: ${origin}`);
-                this.emitWarning(error);
+                catch (e) { }
+            }
+            const middlewareHandshakeStream = new MiddlewareStream(MiddlewareType.MIDDLEWARE_HANDSHAKE);
+            req['handshakeStream'] = middlewareHandshakeStream;
+            const handshakeMiddleware = this._middleware[MiddlewareType.MIDDLEWARE_HANDSHAKE];
+            if (handshakeMiddleware) {
+                handshakeMiddleware(middlewareHandshakeStream);
+            }
+            const action = new ActionHandshakeWS(req);
+            try {
+                await this._processMiddlewareAction(middlewareHandshakeStream, action);
+            }
+            catch (error) {
                 middlewareHandshakeStream.close();
-                callback(false, 403, error.message);
-            });
+                callback(false, 401, typeof error === 'string' ? error : error.message);
+                return;
+            }
+            if (ok) {
+                callback(true);
+                return;
+            }
+            const error = new ServerProtocolError(`Failed to authorize socket handshake - Invalid origin: ${origin}`);
+            this.emitWarning(error);
+            middlewareHandshakeStream.close();
+            callback(false, 403, error.message);
         };
         let opts = {
             brokerEngine: new SimpleBroker(),
@@ -117,40 +99,22 @@ export class Server extends AsyncStreamEmitter {
         this.brokerEngine = opts.brokerEngine;
         this.middlewareEmitFailures = opts.middlewareEmitFailures;
         this._path = opts.path;
-        (() => __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            try {
-                for (var _d = true, _e = __asyncValues(this.brokerEngine.listen('error')), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
-                    _c = _f.value;
-                    _d = false;
-                    try {
-                        let { error } = _c;
-                        this.emitWarning(error);
-                    }
-                    finally {
-                        _d = true;
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_1) throw e_1.error; }
+        (async () => {
+            for await (let { error } of this.brokerEngine.listen('error')) {
+                this.emitWarning(error);
             }
-        }))();
+        })();
         if (this.brokerEngine.isReady) {
             this.isReady = true;
             this.emit('ready', {});
         }
         else {
             this.isReady = false;
-            (() => __awaiter(this, void 0, void 0, function* () {
-                yield this.brokerEngine.listen('ready').once();
+            (async () => {
+                await this.brokerEngine.listen('ready').once();
                 this.isReady = true;
                 this.emit('ready', {});
-            }))();
+            })();
         }
         //		let wsEngine = typeof opts.wsEngine === 'string' ? require(opts.wsEngine) : opts.wsEngine;
         //		if (!wsEngine || !wsEngine.Server) {
@@ -228,7 +192,7 @@ export class Server extends AsyncStreamEmitter {
         if (wsServerOptions.clientTracking == null) {
             wsServerOptions.clientTracking = false;
         }
-        this.wsServer = new ws.Server(wsServerOptions);
+        this.wsServer = new WebSocketServer(wsServerOptions);
         this.wsServer.on('error', this._handleServerError.bind(this));
         this.wsServer.on('connection', this._handleSocketConnection.bind(this));
     }
@@ -308,10 +272,10 @@ export class Server extends AsyncStreamEmitter {
             type !== MiddlewareType.MIDDLEWARE_INBOUND_RAW &&
             type !== MiddlewareType.MIDDLEWARE_INBOUND &&
             type !== MiddlewareType.MIDDLEWARE_OUTBOUND) {
-            throw new InvalidArgumentsError(`Middleware type "${type}" is not supported`);
+            throw new InvalidArgumentsError(`Middleware ${type} type is not supported`);
         }
         if (this._middleware[type]) {
-            throw new InvalidActionError(`Middleware type "${type}" has already been set`);
+            throw new InvalidActionError(`Middleware ${type} type has already been set`);
         }
         this._middleware[type] = middleware;
     }
@@ -321,47 +285,45 @@ export class Server extends AsyncStreamEmitter {
     hasMiddleware(type) {
         return !!this._middleware[type];
     }
-    _processMiddlewareAction(middlewareStream, action, socket) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.hasMiddleware(middlewareStream.type)) {
-                return { data: 'data' in action ? action.data : undefined };
+    async _processMiddlewareAction(middlewareStream, action, socket) {
+        if (!this.hasMiddleware(middlewareStream.type)) {
+            return { data: 'data' in action ? action.data : undefined };
+        }
+        middlewareStream.write(action);
+        let newData;
+        let options;
+        try {
+            const result = await action.promise;
+            if (result) {
+                newData = result.data;
+                options = result.options;
             }
-            middlewareStream.write(action);
-            let newData;
-            let options;
-            try {
-                const result = yield action.promise;
-                if (result) {
-                    newData = result.data;
-                    options = result.options;
-                }
+        }
+        catch (error) {
+            let clientError;
+            if (!error) {
+                error = new SilentMiddlewareBlockedError(`The ${action.type} Action was blocked by ${middlewareStream.type} middleware`, middlewareStream.type);
+                clientError = error;
             }
-            catch (error) {
-                let clientError;
-                if (!error) {
-                    error = new SilentMiddlewareBlockedError(`The ${action.type} Action was blocked by ${middlewareStream.type} middleware`, middlewareStream.type);
-                    clientError = error;
-                }
-                else if (error.silent) {
-                    clientError = new SilentMiddlewareBlockedError(`The ${action.type} Action was blocked by ${middlewareStream.type} middleware`, middlewareStream.type);
+            else if (error.silent) {
+                clientError = new SilentMiddlewareBlockedError(`The ${action.type} Action was blocked by ${middlewareStream.type} middleware`, middlewareStream.type);
+            }
+            else {
+                clientError = error;
+            }
+            if (this.middlewareEmitFailures) {
+                if (socket) {
+                    socket.emitError(error);
                 }
                 else {
-                    clientError = error;
-                }
-                if (this.middlewareEmitFailures) {
-                    if (socket) {
-                        socket.emitError(error);
-                    }
-                    else {
-                        this.emitWarning(error);
-                    }
+                    this.emitWarning(error);
                 }
-                throw clientError;
             }
-            if (newData === undefined && 'data' in action) {
-                newData = action.data;
-            }
-            return { data: newData, options };
-        });
+            throw clientError;
+        }
+        if (newData === undefined && 'data' in action) {
+            newData = action.data;
+        }
+        return { data: newData, options };
     }
 }

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.js";
+import { Request } from "@socket-mesh/request";
+export declare class ServerSocketProcedure extends StreamDemuxWrapper<InboundRequest> {
+    constructor(stream: StreamDemux<InboundRequest>);
+    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>;
+    listen<U>(name: string): DemuxedConsumableStream<Request<U>>;
+    listen<U, 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

@@ -1,21 +1,21 @@
 /// <reference types="node" />
 /// <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.js";
 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 { 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 { SocketState } from "./socket-state.js";
+import { ActionMessage, ActionPublishOut, HandshakeAction, InboundAction } from "./action.js";
+import { AuthStateChanged, AuthTokenSigned, Authenticated, BadAuthToken, Closed, ConnectAborted, Connected, Deauthenticated, Disconnected, ErrorOccurred, RawMessage, ServerSocketEvents, Subscribed, Unsubscribed } from './events.js';
+import { MiddlewareStream } from './middleware-stream.js';
+import { ProtocolVersions } from './server-options.js';
 import ws from "ws";
-import { Server } from "./server";
-import { OutboundPacket, OutboundPacketOptions } from './outbound-packet';
-import { InboundRequest } from './request';
+import { Server } from "./server.js";
+import { OutboundPacket, OutboundPacketOptions } from './outbound-packet.js';
+import { ServerSocketProcedure } from './serversocket-procedure.js';
 export type WebSocket = ws.WebSocket & {
     bytesReceived: number;
     upgradeReq: IncomingMessage;
@@ -31,7 +31,7 @@ interface EventObject {
     data?: any;
     cid?: number;
 }
-export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEvents> {
+export declare class ServerSocket extends AsyncStreamEmitter<ServerSocketEvents> {
     authState: AuthState;
     authToken: AuthToken | null;
     batchInterval: number;
@@ -51,12 +51,12 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
         [channel: string]: boolean;
     };
     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 outboundPacketStream: WritableConsumableStream<OutboundPacket>;
+    readonly server: Server;
+    readonly middlewareHandshakeStream: MiddlewareStream<HandshakeAction>;
+    readonly middlewareInboundRawStream: MiddlewareStream<ActionMessage>;
+    readonly middlewareInboundStream: MiddlewareStream<InboundAction>;
+    readonly middlewareOutboundStream: MiddlewareStream<ActionPublishOut>;
     readonly remoteAddress?: string;
     readonly remoteFamily?: string;
     readonly remotePort?: number;
@@ -64,8 +64,8 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
     outboundSentMessageCount: number;
     signedAuthToken: SignedAuthToken | null;
     state: SocketState;
-    readonly receiver: StreamDemuxWrapper<string | void | T | ArrayBuffer | Buffer[] | AuthInfo | ChannelOptions>;
-    readonly procedure: StreamDemuxWrapper<InboundRequest<T>>;
+    readonly receiver: StreamDemuxWrapper<any>;
+    readonly procedure: ServerSocketProcedure;
     private _cid;
     private _handshakeTimeoutRef;
     private _pingIntervalTicker;
@@ -76,8 +76,9 @@ export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEven
     private readonly _receiverDemux;
     private readonly _procedureDemux;
     private readonly _sendPing;
-    constructor(id: string, server: Server<T>, socket: WebSocket, protocolVersion: ProtocolVersions);
+    constructor(id: string, server: Server, socket: WebSocket, protocolVersion: ProtocolVersions);
     getBackpressure(): number;
+    get exchange(): import("@socket-mesh/channel").Client<import("@socket-mesh/simple-broker/packet").Packet<any>>;
     getInboundBackpressure(): number;
     getOutboundBackpressure(): number;
     private _startBatchOnHandshake;
@@ -111,7 +112,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 +127,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;