@socket-mesh/server 17.3.6 → 18.0.0

package/serversocket.js

@@ -1,33 +1,18 @@
-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 cloneDeep from 'clone-deep';
 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";
-import { ActionAuthenticate, ActionHandshakeSC, ActionInvoke, ActionMessage, ActionPublishIn, ActionPublishOut, ActionSubscribe, ActionTransmit } from "./action";
-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 { SocketState } from "./socket-state.js";
+import { MiddlewareType } from "./middleware-type.js";
+import { ActionAuthenticate, ActionHandshakeSC, ActionInvoke, ActionMessage, ActionPublishIn, ActionPublishOut, ActionSubscribe, ActionTransmit } from "./action.js";
+import { MiddlewareStream } from './middleware-stream.js';
+import { isAuthenticatePacket, isHandshakePacket, isPublishPacket, isRemoveAuthTokenPacket, isSubscribePacket, isUnsubscribePacket } from './inbound-packet.js';
+import { isPublishOutPacket } from './outbound-packet.js';
+import { AuthenticateRequest, HandshakeRequest, UnsubscribeRequest } from './request.js';
+import { ServerSocketProcedure } from './serversocket-procedure.js';
 const HANDSHAKE_REJECTION_STATUS_CODE = 4008;
 export class ServerSocket extends AsyncStreamEmitter {
     constructor(id, server, socket, protocolVersion) {
@@ -41,7 +26,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;
@@ -116,7 +101,7 @@ export class ServerSocket extends AsyncStreamEmitter {
         this._handleInboundMessageStream(pongMessage);
         this._handleOutboundPacketStream();
         // Receive incoming raw messages
-        this.socket.on('message', (messageBuffer, isBinary) => __awaiter(this, void 0, void 0, function* () {
+        this.socket.on('message', async (messageBuffer, isBinary) => {
             let message = isBinary ? messageBuffer : messageBuffer.toString();
             this.inboundReceivedMessageCount++;
             let isPong = message === pongMessage;
@@ -126,7 +111,7 @@ export class ServerSocket extends AsyncStreamEmitter {
             if (this.server.hasMiddleware(MiddlewareType.MIDDLEWARE_INBOUND_RAW)) {
                 const action = new ActionMessage(this, message);
                 try {
-                    const { data } = yield this.server._processMiddlewareAction(this.middlewareInboundRawStream, action, this);
+                    const { data } = await this.server._processMiddlewareAction(this.middlewareInboundRawStream, action, this);
                     message = data;
                 }
                 catch (error) {
@@ -136,20 +121,20 @@ export class ServerSocket extends AsyncStreamEmitter {
             }
             this.inboundMessageStream.write(message);
             this.emit('message', { message });
-        }));
+        });
     }
     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,463 +143,430 @@ export class ServerSocket extends AsyncStreamEmitter {
             }
         }, this.batchOnHandshakeDuration);
     }
-    ;
-    _handleInboundMessageStream(pongMessage) {
-        var _a, e_1, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                for (var _d = true, _e = __asyncValues(this.inboundMessageStream), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
-                    _c = _f.value;
-                    _d = false;
-                    try {
-                        let message = _c;
-                        this.inboundProcessedMessageCount++;
-                        let isPong = message === pongMessage;
-                        if (isPong) {
-                            if (this.server.strictHandshake && this.state === SocketState.CONNECTING) {
-                                this._destroy(4009);
-                                this.socket.close(4009);
-                                continue;
-                            }
-                            let token = this.getAuthToken();
-                            if (this.isAuthTokenExpired(token)) {
-                                this.deauthenticate();
-                            }
-                            continue;
-                        }
-                        let packet;
-                        try {
-                            packet = this.decode(message);
-                        }
-                        catch (error) {
-                            if (error.name === 'Error') {
-                                error.name = 'InvalidMessageError';
-                            }
-                            this.emitError(error);
-                            if (this.server.strictHandshake && this.state === SocketState.CONNECTING) {
-                                this._destroy(4009);
-                                this.socket.close(4009);
-                            }
-                            continue;
-                        }
-                        if (Array.isArray(packet)) {
-                            let len = packet.length;
-                            for (let i = 0; i < len; i++) {
-                                yield this._processInboundPacket(packet[i], message);
-                            }
-                        }
-                        else {
-                            yield this._processInboundPacket(packet, message);
-                        }
-                    }
-                    finally {
-                        _d = true;
-                    }
+    async _handleInboundMessageStream(pongMessage) {
+        for await (let message of this.inboundMessageStream) {
+            this.inboundProcessedMessageCount++;
+            let isPong = message === pongMessage;
+            if (isPong) {
+                if (this.server.strictHandshake && this.state === SocketState.CONNECTING) {
+                    this._destroy(4009);
+                    this.socket.close(4009);
+                    continue;
                 }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                let token = this.getAuthToken();
+                if (this.isAuthTokenExpired(token)) {
+                    this.deauthenticate();
                 }
-                finally { if (e_1) throw e_1.error; }
+                continue;
             }
-        });
-    }
-    ;
-    _handleHandshakeTimeout() {
-        this.disconnect(4005);
-    }
-    ;
-    _processHandshakeRequest(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let data = request.data || { authToken: '' };
-            let signedAuthToken = data.authToken;
-            clearTimeout(this._handshakeTimeoutRef);
-            const authInfo = yield this._validateAuthToken(signedAuthToken);
-            const action = new ActionHandshakeSC(this, request, authInfo);
+            let packet;
             try {
-                yield this.server._processMiddlewareAction(this.middlewareHandshakeStream, action);
+                packet = this.decode(message);
             }
             catch (error) {
-                if (error.statusCode == null) {
-                    error.statusCode = HANDSHAKE_REJECTION_STATUS_CODE;
+                if (error.name === 'Error') {
+                    error.name = 'InvalidMessageError';
                 }
-                request.error(error);
-                this.disconnect(error.statusCode);
-                return;
-            }
-            const oldAuthState = this.authState;
-            let authError = undefined;
-            try {
-                yield this._processAuthentication(authInfo);
-                if (this.state === SocketState.CLOSED) {
-                    return;
+                this.emitError(error);
+                if (this.server.strictHandshake && this.state === SocketState.CONNECTING) {
+                    this._destroy(4009);
+                    this.socket.close(4009);
                 }
+                continue;
             }
-            catch (error) {
-                if (signedAuthToken != null) {
-                    // Because the token is optional as part of the handshake, we don't count
-                    // it as an error if the token wasn't provided.
-                    authError = dehydrateError(error);
-                    if (error.isBadToken) {
-                        this.deauthenticate();
-                    }
+            if (Array.isArray(packet)) {
+                let len = packet.length;
+                for (let i = 0; i < len; i++) {
+                    await this._processInboundPacket(packet[i], message);
                 }
             }
-            const clientSocketStatus = {
-                id: this.id,
-                pingTimeout: this.server.pingTimeout,
-                isAuthenticated: !!this.authToken,
-                authError: authError
-            };
-            const serverSocketStatus = {
-                id: this.id,
-                pingTimeout: this.server.pingTimeout,
-                isAuthenticated: !!this.authToken,
-                authError: authError
-            };
-            if (this.server.pendingClients[this.id]) {
-                delete this.server.pendingClients[this.id];
-                this.server.pendingClientsCount--;
-            }
-            this.server.clients[this.id] = this;
-            this.server.clientsCount++;
-            this.state = SocketState.OPEN;
-            if (clientSocketStatus.isAuthenticated) {
-                // Needs to be executed after the connection event to allow
-                // consumers to be setup from inside the connection loop.
-                (() => __awaiter(this, void 0, void 0, function* () {
-                    yield this.listen('connect').once();
-                    this.triggerAuthenticationEvents(oldAuthState);
-                }))();
-            }
-            // Treat authentication failure as a 'soft' error
-            request.end(clientSocketStatus);
-            if (this.batchOnHandshake) {
-                this._startBatchOnHandshake();
+            else {
+                await this._processInboundPacket(packet, message);
             }
-            this.emit('connect', serverSocketStatus);
-            this.server.emit('connection', Object.assign({ socket: this }, serverSocketStatus));
-            this.middlewareHandshakeStream.close();
-        });
+        }
     }
-    _processAuthenticateRequest(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let signedAuthToken = request.data;
-            let oldAuthState = this.authState;
-            let authInfo = yield this._validateAuthToken(signedAuthToken);
-            try {
-                yield this._processAuthentication(authInfo);
+    _handleHandshakeTimeout() {
+        this.disconnect(4005);
+    }
+    async _processHandshakeRequest(request) {
+        let data = request.data || { authToken: '' };
+        let signedAuthToken = data.authToken;
+        clearTimeout(this._handshakeTimeoutRef);
+        const authInfo = await this._validateAuthToken(signedAuthToken);
+        const action = new ActionHandshakeSC(this, request, authInfo);
+        try {
+            await this.server._processMiddlewareAction(this.middlewareHandshakeStream, action);
+        }
+        catch (error) {
+            if (error.statusCode == null) {
+                error.statusCode = HANDSHAKE_REJECTION_STATUS_CODE;
             }
-            catch (error) {
-                if (error instanceof AuthTokenError) {
+            request.error(error);
+            this.disconnect(error.statusCode);
+            return;
+        }
+        const oldAuthState = this.authState;
+        let authError = undefined;
+        try {
+            await this._processAuthentication(authInfo);
+            if (this.state === SocketState.CLOSED) {
+                return;
+            }
+        }
+        catch (error) {
+            if (signedAuthToken != null) {
+                // Because the token is optional as part of the handshake, we don't count
+                // it as an error if the token wasn't provided.
+                authError = dehydrateError(error);
+                if (error.isBadToken) {
                     this.deauthenticate();
-                    request.error(error);
-                    return;
                 }
-                request.end({
-                    isAuthenticated: !!this.authToken,
-                    authError: signedAuthToken == null ? null : dehydrateError(error)
-                });
+            }
+        }
+        const clientSocketStatus = {
+            id: this.id,
+            pingTimeout: this.server.pingTimeout,
+            isAuthenticated: !!this.authToken,
+            authError: authError
+        };
+        const serverSocketStatus = {
+            id: this.id,
+            pingTimeout: this.server.pingTimeout,
+            isAuthenticated: !!this.authToken,
+            authError: authError
+        };
+        if (this.server.pendingClients[this.id]) {
+            delete this.server.pendingClients[this.id];
+            this.server.pendingClientsCount--;
+        }
+        this.server.clients[this.id] = this;
+        this.server.clientsCount++;
+        this.state = SocketState.OPEN;
+        if (clientSocketStatus.isAuthenticated) {
+            // Needs to be executed after the connection event to allow
+            // consumers to be setup from inside the connection loop.
+            (async () => {
+                await this.listen('connect').once();
+                this.triggerAuthenticationEvents(oldAuthState);
+            })();
+        }
+        // Treat authentication failure as a 'soft' error
+        request.end(clientSocketStatus);
+        if (this.batchOnHandshake) {
+            this._startBatchOnHandshake();
+        }
+        this.emit('connect', serverSocketStatus);
+        this.server.emit('connection', { socket: this, ...serverSocketStatus });
+        this.middlewareHandshakeStream.close();
+    }
+    async _processAuthenticateRequest(request) {
+        let signedAuthToken = request.data;
+        let oldAuthState = this.authState;
+        let authInfo = await this._validateAuthToken(signedAuthToken);
+        try {
+            await this._processAuthentication(authInfo);
+        }
+        catch (error) {
+            if (error instanceof AuthTokenError) {
+                this.deauthenticate();
+                request.error(error);
                 return;
             }
-            this.triggerAuthenticationEvents(oldAuthState);
             request.end({
                 isAuthenticated: !!this.authToken,
-                authError: null
+                authError: signedAuthToken == null ? null : dehydrateError(error)
             });
+            return;
+        }
+        this.triggerAuthenticationEvents(oldAuthState);
+        request.end({
+            isAuthenticated: !!this.authToken,
+            authError: null
         });
     }
-    _subscribeSocket(channelName, subscriptionOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (channelName === undefined || !subscriptionOptions) {
-                throw new InvalidActionError(`Socket ${this.id} provided a malformated channel payload`);
-            }
-            if (this.server.socketChannelLimit && this.channelSubscriptionsCount >= this.server.socketChannelLimit) {
-                throw new InvalidActionError(`Socket ${this.id} tried to exceed the channel subscription limit of ${this.server.socketChannelLimit}`);
-            }
-            if (typeof channelName !== 'string') {
-                throw new InvalidActionError(`Socket ${this.id} provided an invalid channel name`);
-            }
-            if (this.channelSubscriptionsCount == null) {
-                this.channelSubscriptionsCount = 0;
-            }
-            if (this.channelSubscriptions[channelName] == null) {
-                this.channelSubscriptions[channelName] = true;
-                this.channelSubscriptionsCount++;
-            }
-            try {
-                this.server.brokerEngine.subscribeSocket(this, channelName);
-            }
-            catch (error) {
-                delete this.channelSubscriptions[channelName];
-                this.channelSubscriptionsCount--;
-                throw error;
-            }
-            this.emit('subscribe', {
-                channel: channelName,
-                subscriptionOptions
-            });
-            this.server.emit('subscription', {
-                socket: this,
-                channel: channelName,
-                subscriptionOptions
-            });
+    async _subscribeSocket(channelName, subscriptionOptions) {
+        if (this.server.socketChannelLimit && this.channelSubscriptionsCount >= this.server.socketChannelLimit) {
+            throw new InvalidActionError(`Socket ${this.id} tried to exceed the channel subscription limit of ${this.server.socketChannelLimit}`);
+        }
+        if (this.channelSubscriptionsCount == null) {
+            this.channelSubscriptionsCount = 0;
+        }
+        if (this.channelSubscriptions[channelName] == null) {
+            this.channelSubscriptions[channelName] = true;
+            this.channelSubscriptionsCount++;
+        }
+        try {
+            this.server.brokerEngine.subscribeSocket(this, channelName);
+        }
+        catch (error) {
+            delete this.channelSubscriptions[channelName];
+            this.channelSubscriptionsCount--;
+            throw error;
+        }
+        this.emit('subscribe', {
+            channel: channelName,
+            subscriptionOptions
+        });
+        this.server.emit('subscription', {
+            socket: this,
+            channel: channelName,
+            subscriptionOptions
         });
     }
-    ;
-    _processSubscribeRequest(request) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async _processSubscribeRequest(request) {
+        if (this.state === SocketState.OPEN) {
             let subscriptionOptions = Object.assign({}, request.data);
             let channelName = subscriptionOptions.channel;
             delete subscriptionOptions.channel;
-            if (this.state === SocketState.OPEN) {
-                try {
-                    yield this._subscribeSocket(channelName, subscriptionOptions);
-                }
-                catch (err) {
-                    let error = new BrokerError(`Failed to subscribe socket to the ${channelName} channel - ${err}`);
-                    this.emitError(error);
-                    request.error(error);
-                    return;
-                }
-                request.end();
-                return;
-            }
-            // This is an invalid state; it means the client tried to subscribe before
-            // having completed the handshake.
-            let error = new InvalidActionError('Cannot subscribe socket to a channel before it has completed the handshake');
-            this.emitError(error);
-            request.error(error);
-        });
-    }
-    _unsubscribeFromAllChannels() {
-        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') {
-                throw new InvalidActionError(`Socket ${this.id} tried to unsubscribe from an invalid channel name`);
-            }
-            if (!this.channelSubscriptions[channel]) {
-                throw new InvalidActionError(`Socket ${this.id} tried to unsubscribe from a channel which it is not subscribed to`);
-            }
             try {
-                yield this.server.brokerEngine.unsubscribeSocket(this, channel);
-                delete this.channelSubscriptions[channel];
-                if (this.channelSubscriptionsCount != null) {
-                    this.channelSubscriptionsCount--;
-                }
-                this.emit('unsubscribe', { channel });
-                this.server.emit('unsubscription', { socket: this, channel });
+                await this._subscribeSocket(channelName, subscriptionOptions);
             }
             catch (err) {
-                const error = new BrokerError(`Failed to unsubscribe socket from the ${channel} channel - ${err}`);
-                this.emitError(error);
-            }
-        });
-    }
-    ;
-    _processUnsubscribePacket(packet) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let channel = packet.data;
-            try {
-                yield this._unsubscribe(channel);
-            }
-            catch (err) {
-                let error = new BrokerError(`Failed to unsubscribe socket from the ${channel} channel - ${err}`);
-                this.emitError(error);
-            }
-        });
-    }
-    ;
-    _processUnsubscribeRequest(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const channel = request.data;
-            try {
-                yield this._unsubscribe(channel);
-            }
-            catch (err) {
-                let error = new BrokerError(`Failed to unsubscribe socket from the ${channel} channel - ${err}`);
+                let error = new BrokerError(`Failed to subscribe socket to the ${channelName} channel - ${err}`);
                 this.emitError(error);
                 request.error(error);
                 return;
             }
             request.end();
-        });
+            return;
+        }
+        // This is an invalid state; it means the client tried to subscribe before
+        // having completed the handshake.
+        let error = new InvalidActionError('Cannot subscribe socket to a channel before it has completed the handshake');
+        this.emitError(error);
+        request.error(error);
     }
-    _processInboundPublishPacket(packet) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let data = packet.data || {};
-            if (!data.channel || typeof data.channel !== 'string') {
-                let error = new InvalidActionError(`Socket ${this.id} tried to invoke publish to an invalid "${data.channel}" channel`);
-                this.emitError(error);
-                return;
-            }
-            try {
-                yield this.server.exchange.invokePublish(data.channel, data.data);
-            }
-            catch (error) {
-                this.emitError(error);
+    async _unsubscribeFromAllChannels() {
+        const channels = Object.keys(this.channelSubscriptions);
+        await Promise.all(channels.map((channel) => this._unsubscribe(channel)));
+    }
+    async _unsubscribe(channel) {
+        if (typeof channel !== 'string') {
+            throw new InvalidActionError(`Socket ${this.id} tried to unsubscribe from an invalid channel name`);
+        }
+        if (!this.channelSubscriptions[channel]) {
+            throw new InvalidActionError(`Socket ${this.id} tried to unsubscribe from a channel which it is not subscribed to`);
+        }
+        try {
+            await this.server.brokerEngine.unsubscribeSocket(this, channel);
+            delete this.channelSubscriptions[channel];
+            if (this.channelSubscriptionsCount != null) {
+                this.channelSubscriptionsCount--;
             }
-        });
+            this.emit('unsubscribe', { channel });
+            this.server.emit('unsubscription', { socket: this, channel });
+        }
+        catch (err) {
+            const error = new BrokerError(`Failed to unsubscribe socket from the ${channel} channel - ${err}`);
+            this.emitError(error);
+        }
     }
-    _processInboundPublishRequest(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let data = request.data || {};
-            if (typeof data.channel !== 'string') {
-                let error = new InvalidActionError(`Socket ${this.id} tried to transmit publish to an invalid "${data.channel}" channel`);
-                this.emitError(error);
-                request.error(error);
+    async _processUnsubscribePacket(packet) {
+        let channel = packet.data;
+        try {
+            await this._unsubscribe(channel);
+        }
+        catch (err) {
+            let error = new BrokerError(`Failed to unsubscribe socket from the ${channel} channel - ${err}`);
+            this.emitError(error);
+        }
+    }
+    async _processUnsubscribeRequest(request) {
+        const channel = request.data;
+        try {
+            await this._unsubscribe(channel);
+        }
+        catch (err) {
+            let error = new BrokerError(`Failed to unsubscribe socket from the ${channel} channel - ${err}`);
+            this.emitError(error);
+            request.error(error);
+            return;
+        }
+        request.end();
+    }
+    async _processInboundPublishPacket(packet) {
+        try {
+            await this.server.exchange.invokePublish(packet.data.channel, packet.data.data);
+        }
+        catch (error) {
+            this.emitError(error);
+        }
+    }
+    async _processInboundPublishRequest(request) {
+        try {
+            await this.server.exchange.invokePublish(request.data.channel, request.data.data);
+        }
+        catch (error) {
+            this.emitError(error);
+            request.error(error);
+            return;
+        }
+        request.end();
+    }
+    async _processInboundPacket(packet, message) {
+        if (packet && typeof packet.event === 'string') {
+            let isRPC = ('cid' in packet) && typeof packet.cid === 'number';
+            if (isHandshakePacket(packet)) {
+                if (!isRPC) {
+                    let error = new InvalidActionError('Handshake request was malformatted');
+                    this.emitError(error);
+                    this._destroy(HANDSHAKE_REJECTION_STATUS_CODE);
+                    this.socket.close(HANDSHAKE_REJECTION_STATUS_CODE);
+                    return;
+                }
+                const request = new HandshakeRequest(this, packet.cid, packet.event, packet.data);
+                await this._processHandshakeRequest(request);
+                this._procedureDemux.write(request.procedure, request);
                 return;
             }
-            try {
-                yield this.server.exchange.invokePublish(data.channel, data.data);
-            }
-            catch (error) {
-                this.emitError(error);
-                request.error(error);
+            if (this.server.strictHandshake && this.state === SocketState.CONNECTING) {
+                this._destroy(4009);
+                this.socket.close(4009);
                 return;
             }
-            request.end();
-        });
-    }
-    _processInboundPacket(packet, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (packet && packet.event != null) {
-                let isRPC = ('cid' in packet);
-                if (isHandshakePacket(packet)) {
-                    const request = new HandshakeRequest(this, packet.cid, packet.event, packet.data);
-                    yield this._processHandshakeRequest(request);
-                    this._procedureDemux.write(request.procedure, request);
+            if (isAuthenticatePacket(packet)) {
+                if (!isRPC) {
+                    let error = new InvalidActionError('Authenticate request was malformatted');
+                    this.emitError(error);
+                    this._destroy(HANDSHAKE_REJECTION_STATUS_CODE);
+                    this.socket.close(HANDSHAKE_REJECTION_STATUS_CODE);
                     return;
                 }
-                if (this.server.strictHandshake && this.state === SocketState.CONNECTING) {
-                    this._destroy(4009);
-                    this.socket.close(4009);
+                // Let AGServer handle these events.
+                const request = new AuthenticateRequest(this, packet.cid, packet.event, packet.data);
+                await this._processAuthenticateRequest(request);
+                this._procedureDemux.write(request.procedure, request);
+                return;
+            }
+            if (isRemoveAuthTokenPacket(packet)) {
+                this.deauthenticateSelf();
+                this._receiverDemux.write(packet.event, packet.data);
+                return;
+            }
+            if (isUnsubscribePacket(packet)) {
+                if (typeof packet.data !== 'string') {
+                    const error = new InvalidActionError('Unsubscribe channel name was malformatted');
+                    this.emitError(error);
+                    if (isRPC) {
+                        const request = new Request(this, packet.cid, packet.event, packet.data);
+                        request.error(error);
+                    }
                     return;
                 }
-                if (isAuthenticatePacket(packet)) {
-                    // Let AGServer handle these events.
-                    const request = new AuthenticateRequest(this, packet.cid, packet.event, packet.data);
-                    yield this._processAuthenticateRequest(request);
+                if (isRPC) {
+                    const request = new UnsubscribeRequest(this, packet.cid, packet.event, packet.data);
+                    await this._processUnsubscribeRequest(request);
                     this._procedureDemux.write(request.procedure, request);
                     return;
                 }
-                if (isRemoveAuthTokenPacket(packet)) {
-                    this.deauthenticateSelf();
-                    this._receiverDemux.write(packet.event, packet.data);
-                    return;
-                }
-                if (isUnsubscribePacket(packet)) {
+                await this._processUnsubscribePacket(packet);
+                this._receiverDemux.write(packet.event, packet.data);
+                return;
+            }
+            let action;
+            if (isPublishPacket(packet)) {
+                if (!this.server.allowClientPublish) {
+                    let error = new InvalidActionError('Client publish feature is disabled');
+                    this.emitError(error);
                     if (isRPC) {
-                        const request = new UnsubscribeRequest(this, packet.cid, packet.event, packet.data);
-                        yield this._processUnsubscribeRequest(request);
-                        this._procedureDemux.write(request.procedure, request);
-                        return;
+                        const request = new Request(this, packet.cid, packet.event, packet.data);
+                        request.error(error);
                     }
-                    yield this._processUnsubscribePacket(packet);
-                    this._receiverDemux.write(packet.event, packet.data);
                     return;
                 }
-                let action;
-                if (isPublishPacket(packet)) {
-                    if (!this.server.allowClientPublish) {
-                        let error = new InvalidActionError('Client publish feature is disabled');
-                        this.emitError(error);
-                        if (isRPC) {
-                            const request = new Request(this, packet.cid, packet.event, packet.data);
-                            request.error(error);
-                        }
-                        return;
+                if (!packet.data || typeof packet.data.channel !== 'string') {
+                    const error = new InvalidActionError('Publish channel name was malformatted');
+                    this.emitError(error);
+                    if (isRPC) {
+                        const request = new Request(this, packet.cid, packet.event, packet.data);
+                        request.error(error);
                     }
-                    action = new ActionPublishIn(this, packet.data);
-                }
-                else if (isSubscribePacket(packet)) {
-                    action = new ActionSubscribe(this, packet.data);
-                }
-                else if (isRPC) {
-                    action = new ActionInvoke(this, packet.event, packet.data);
-                }
-                else {
-                    action = new ActionTransmit(this, packet.event, packet.data);
-                }
-                const tokenExpiredError = this._processAuthTokenExpiry();
-                if (tokenExpiredError) {
-                    action.authTokenExpiredError = tokenExpiredError;
+                    return;
                 }
-                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) {
+                action = new ActionPublishIn(this, packet.data);
+            }
+            else if (isSubscribePacket(packet)) {
+                if (!packet.data || typeof packet.data.channel !== 'string') {
+                    const error = new InvalidActionError('Subscribe channel name was malformatted');
+                    this.emitError(error);
+                    if (isRPC) {
+                        const request = new Request(this, packet.cid, packet.event, packet.data);
                         request.error(error);
-                        return;
-                    }
-                    if (isSubscribeRequest(request)) {
-                        if (!request.data) {
-                            request.data = {};
-                        }
-                        request.data.data = newData;
-                        yield this._processSubscribeRequest(request);
                     }
-                    else if (isPublishRequest(request)) {
-                        if (!request.data) {
-                            request.data = {};
-                        }
-                        request.data.data = newData;
-                        yield this._processInboundPublishRequest(request);
-                    }
-                    else {
-                        request.data = newData;
-                    }
-                    this._procedureDemux.write(request.procedure, request);
                     return;
                 }
+                action = new ActionSubscribe(this, packet.data);
+            }
+            else if (isRPC) {
+                action = new ActionInvoke(this, packet.event, packet.data);
+            }
+            else {
+                action = new ActionTransmit(this, packet.event, packet.data);
+            }
+            const tokenExpiredError = this._processAuthTokenExpiry();
+            if (tokenExpiredError) {
+                action.authTokenExpiredError = tokenExpiredError;
+            }
+            let newData;
+            if (isRPC) {
                 try {
-                    let { data } = yield this.server._processMiddlewareAction(this.middlewareInboundStream, action, this);
+                    let { data } = await this.server._processMiddlewareAction(this.middlewareInboundStream, action, this);
                     newData = data;
                 }
                 catch (error) {
+                    this.sendObject(createErrorResponse(packet.cid, error));
                     return;
                 }
-                if (isPublishPacket(packet)) {
-                    if (!packet.data) {
-                        packet.data = {};
+                let request;
+                if (isSubscribePacket(packet) || isPublishPacket(packet)) {
+                    request = new Request(this, packet.cid, packet.event, packet.data);
+                    request.data.data = newData;
+                    if (isSubscribePacket(packet)) {
+                        await this._processSubscribeRequest(request);
+                    }
+                    else {
+                        await this._processInboundPublishRequest(request);
                     }
-                    packet.data.data = newData;
-                    yield this._processInboundPublishPacket(packet);
                 }
-                this._receiverDemux.write(packet.event, newData);
+                else {
+                    request = new RequestWithResponse(this, packet.cid, packet.event, newData);
+                }
+                this._procedureDemux.write(request.procedure, request);
                 return;
             }
-            if (this.server.strictHandshake && this.state === SocketState.CONNECTING) {
-                this._destroy(4009);
-                this.socket.close(4009);
-                return;
+            try {
+                let { data } = await this.server._processMiddlewareAction(this.middlewareInboundStream, action, this);
+                newData = data;
             }
-            if (packet && 'rid' in packet) {
-                // If incoming message is a response to a previously sent message
-                const ret = this._callbackMap[packet.rid];
-                if (ret) {
-                    clearTimeout(ret.timeout);
-                    delete this._callbackMap[packet.rid];
-                    const rehydratedError = hydrateError(packet.error);
-                    ret.callback(rehydratedError, packet.data);
-                }
+            catch (error) {
                 return;
             }
-            // The last remaining case is to treat the message as raw
-            this.emit('raw', { message });
-        });
+            if (isPublishPacket(packet)) {
+                packet.data.data = newData;
+                await this._processInboundPublishPacket(packet);
+            }
+            this._receiverDemux.write(packet.event, newData);
+            return;
+        }
+        if (this.server.strictHandshake && this.state === SocketState.CONNECTING) {
+            this._destroy(4009);
+            this.socket.close(4009);
+            return;
+        }
+        if (packet && 'rid' in packet && typeof packet.rid === 'number') {
+            // If incoming message is a response to a previously sent message
+            const ret = this._callbackMap[packet.rid];
+            if (ret) {
+                clearTimeout(ret.timeout);
+                delete this._callbackMap[packet.rid];
+                const rehydratedError = hydrateError(packet.error);
+                ret.callback(rehydratedError, packet.data);
+            }
+            return;
+        }
+        // The last remaining case is to treat the message as raw
+        this.emit('raw', { message });
     }
-    ;
     _resetPongTimeout() {
         if (this.server.pingTimeoutDisabled) {
             return;
@@ -644,7 +596,7 @@ export class ServerSocket extends AsyncStreamEmitter {
             delete this._callbackMap[i];
             clearTimeout(eventObject.timeout);
             delete eventObject.timeout;
-            const errorMessage = `Event "${eventObject.event}" was aborted due to a bad connection`;
+            const errorMessage = `Event ${eventObject.event} was aborted due to a bad connection`;
             const badConnectionError = new BadConnectionError(errorMessage, failureType);
             const callback = eventObject.callback;
             delete eventObject.callback;
@@ -697,71 +649,69 @@ export class ServerSocket extends AsyncStreamEmitter {
         this.procedure.kill();
         this.killListeners();
     }
-    _destroy(code, reason) {
-        return __awaiter(this, void 0, void 0, function* () {
-            clearInterval(this._pingIntervalTicker);
-            clearTimeout(this._pingTimeoutTicker);
-            this._cancelBatching();
-            if (this.state === SocketState.CLOSED) {
+    async _destroy(code, reason) {
+        clearInterval(this._pingIntervalTicker);
+        clearTimeout(this._pingTimeoutTicker);
+        this._cancelBatching();
+        if (this.state === SocketState.CLOSED) {
+            this._abortAllPendingEventsDueToBadConnection('connectAbort');
+        }
+        else {
+            if (!reason) {
+                reason = socketProtocolErrorStatuses[code];
+            }
+            const prevState = this.state;
+            this.state = SocketState.CLOSED;
+            if (prevState === SocketState.CONNECTING) {
                 this._abortAllPendingEventsDueToBadConnection('connectAbort');
+                this.emit('connectAbort', { code, reason });
+                this.server.emit('connectionAbort', { socket: this, code, reason });
             }
             else {
-                if (!reason) {
-                    reason = socketProtocolErrorStatuses[code];
-                }
-                const prevState = this.state;
-                this.state = SocketState.CLOSED;
-                if (prevState === SocketState.CONNECTING) {
-                    this._abortAllPendingEventsDueToBadConnection('connectAbort');
-                    this.emit('connectAbort', { code, reason });
-                    this.server.emit('connectionAbort', { socket: this, code, reason });
+                this._abortAllPendingEventsDueToBadConnection('disconnect');
+                this.emit('disconnect', { code, reason });
+                this.server.emit('disconnection', { socket: this, code, reason });
+            }
+            this.emit('close', { code, reason });
+            this.server.emit('closure', { socket: this, code, reason });
+            clearTimeout(this._handshakeTimeoutRef);
+            let isClientFullyConnected = !!this.server.clients[this.id];
+            if (isClientFullyConnected) {
+                delete this.server.clients[this.id];
+                this.server.clientsCount--;
+            }
+            let isClientPending = !!this.server.pendingClients[this.id];
+            if (isClientPending) {
+                delete this.server.pendingClients[this.id];
+                this.server.pendingClientsCount--;
+            }
+            if (!socketProtocolIgnoreStatuses[code]) {
+                let closeMessage;
+                if (typeof reason === 'string') {
+                    closeMessage = `Socket connection closed with status code ${code} and reason: ${reason}`;
                 }
                 else {
-                    this._abortAllPendingEventsDueToBadConnection('disconnect');
-                    this.emit('disconnect', { code, reason });
-                    this.server.emit('disconnection', { socket: this, code, reason });
-                }
-                this.emit('close', { code, reason });
-                this.server.emit('closure', { socket: this, code, reason });
-                clearTimeout(this._handshakeTimeoutRef);
-                let isClientFullyConnected = !!this.server.clients[this.id];
-                if (isClientFullyConnected) {
-                    delete this.server.clients[this.id];
-                    this.server.clientsCount--;
-                }
-                let isClientPending = !!this.server.pendingClients[this.id];
-                if (isClientPending) {
-                    delete this.server.pendingClients[this.id];
-                    this.server.pendingClientsCount--;
+                    closeMessage = `Socket connection closed with status code ${code}`;
                 }
-                if (!socketProtocolIgnoreStatuses[code]) {
-                    let closeMessage;
-                    if (reason) {
-                        closeMessage = `Socket connection closed with status code ${code} and reason: ${reason}`;
-                    }
-                    else {
-                        closeMessage = `Socket connection closed with status code ${code}`;
-                    }
-                    let err = new SocketProtocolError(socketProtocolErrorStatuses[code] || closeMessage, code);
-                    this.emitError(err);
-                }
-                yield this._unsubscribeFromAllChannels();
-                let cleanupMode = this.server.options.socketStreamCleanupMode;
-                if (cleanupMode === 'kill') {
-                    (() => __awaiter(this, void 0, void 0, function* () {
-                        yield this.listen('end').once();
-                        this.killAllStreams();
-                    }))();
-                }
-                else if (cleanupMode === 'close') {
-                    (() => __awaiter(this, void 0, void 0, function* () {
-                        yield this.listen('end').once();
-                        this.closeAllStreams();
-                    }))();
-                }
-                this.emit('end');
+                let err = new SocketProtocolError(socketProtocolErrorStatuses[code] || closeMessage, code);
+                this.emitError(err);
             }
-        });
+            await this._unsubscribeFromAllChannels();
+            let cleanupMode = this.server.options.socketStreamCleanupMode;
+            if (cleanupMode === 'kill') {
+                (async () => {
+                    await this.listen('end').once();
+                    this.killAllStreams();
+                })();
+            }
+            else if (cleanupMode === 'close') {
+                (async () => {
+                    await this.listen('end').once();
+                    this.closeAllStreams();
+                })();
+            }
+            this.emit('end');
+        }
     }
     disconnect(code, reason) {
         code = code || 1000;
@@ -850,7 +800,6 @@ export class ServerSocket extends AsyncStreamEmitter {
         this.isBatching = false;
         this._cancelBatching();
     }
-    ;
     serializeObject(object) {
         let str;
         try {
@@ -862,7 +811,6 @@ export class ServerSocket extends AsyncStreamEmitter {
         }
         return str;
     }
-    ;
     sendObject(object) {
         if (this.isBufferingBatch) {
             this._batchBuffer.push(object);
@@ -873,47 +821,27 @@ export class ServerSocket extends AsyncStreamEmitter {
             this.send(str);
         }
     }
-    _handleOutboundPacketStream() {
-        var _a, e_2, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                for (var _d = true, _e = __asyncValues(this.outboundPacketStream), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
-                    _c = _f.value;
-                    _d = false;
+    async _handleOutboundPacketStream() {
+        for await (let packet of this.outboundPacketStream) {
+            if ('resolve' in packet) {
+                // Invoke has no middleware, so there is no need to await here.
+                (async () => {
+                    let result;
                     try {
-                        let packet = _c;
-                        if ('resolve' in packet) {
-                            // Invoke has no middleware, so there is no need to await here.
-                            (() => __awaiter(this, void 0, void 0, function* () {
-                                let result;
-                                try {
-                                    result = yield this._invoke(packet);
-                                }
-                                catch (error) {
-                                    packet.reject(error);
-                                    return;
-                                }
-                                packet.resolve(result);
-                            }))();
-                            this.outboundSentMessageCount++;
-                            continue;
-                        }
-                        yield this._processTransmit(packet);
-                        this.outboundSentMessageCount++;
+                        result = await this._invoke(packet);
                     }
-                    finally {
-                        _d = true;
+                    catch (error) {
+                        packet.reject(error);
+                        return;
                     }
-                }
+                    packet.resolve(result);
+                })();
+                this.outboundSentMessageCount++;
+                continue;
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-        });
+            await this._processTransmit(packet);
+            this.outboundSentMessageCount++;
+        }
     }
     _transmit(event, data, options) {
         if (this.cloneData) {
@@ -928,31 +856,29 @@ export class ServerSocket extends AsyncStreamEmitter {
     }
     transmit(event, data, options) {
         if (this.state !== SocketState.OPEN) {
-            let error = new BadConnectionError(`Socket transmit "${event}" was aborted due to a bad connection`, 'connectAbort');
+            let error = new BadConnectionError(`Socket transmit ${event} event was aborted due to a bad connection`, 'connectAbort');
             this.emitError(error);
             return;
         }
         this._transmit(event, data, options);
     }
-    invoke(event, data, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.state !== SocketState.OPEN) {
-                const error = new BadConnectionError(`Socket invoke "${event}" was aborted due to a bad connection`, 'connectAbort');
-                this.emitError(error);
-                throw error;
-            }
-            if (this.cloneData) {
-                data = cloneDeep(data);
-            }
-            this.outboundPreparedMessageCount++;
-            return new Promise((resolve, reject) => {
-                this.outboundPacketStream.write({
-                    event,
-                    data,
-                    options,
-                    resolve,
-                    reject
-                });
+    async invoke(event, data, options) {
+        if (this.state !== SocketState.OPEN) {
+            const error = new BadConnectionError(`Socket invoke ${event} event was aborted due to a bad connection`, 'connectAbort');
+            this.emitError(error);
+            throw error;
+        }
+        if (this.cloneData) {
+            data = cloneDeep(data);
+        }
+        this.outboundPreparedMessageCount++;
+        return new Promise((resolve, reject) => {
+            this.outboundPacketStream.write({
+                event,
+                data,
+                options,
+                resolve,
+                reject
             });
         });
     }
@@ -962,86 +888,82 @@ export class ServerSocket extends AsyncStreamEmitter {
     listen(eventName) {
         return super.listen(eventName);
     }
-    _processTransmit(packet) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let newData;
-            let useCache = packet.options ? packet.options.useCache : false;
+    async _processTransmit(packet) {
+        let newData;
+        let useCache = packet.options ? packet.options.useCache : false;
+        if (isPublishOutPacket(packet)) {
+            const action = new ActionPublishOut(this);
+            if (packet.data !== undefined) {
+                action.channel = packet.data.channel;
+                action.data = packet.data.data;
+            }
+            useCache = !this.server.hasMiddleware(this.middlewareOutboundStream.type);
+            try {
+                const { data, options } = await this.server._processMiddlewareAction(this.middlewareOutboundStream, action, this);
+                newData = data;
+                useCache = options == null ? useCache : options.useCache;
+            }
+            catch (error) {
+                return;
+            }
+        }
+        else {
+            newData = packet.data;
+        }
+        if (packet.options && useCache && packet.options.stringifiedData != null && !this.isBufferingBatch) {
+            // Optimized
+            this.send(packet.options.stringifiedData);
+        }
+        else {
+            const eventObject = {
+                event: packet.event
+            };
             if (isPublishOutPacket(packet)) {
-                const action = new ActionPublishOut(this);
-                if (packet.data !== undefined) {
-                    action.channel = packet.data.channel;
-                    action.data = packet.data.data;
-                }
-                useCache = !this.server.hasMiddleware(this.middlewareOutboundStream.type);
-                try {
-                    const { data, options } = yield this.server._processMiddlewareAction(this.middlewareOutboundStream, action, this);
-                    newData = data;
-                    useCache = options == null ? useCache : options.useCache;
-                }
-                catch (error) {
-                    return;
-                }
+                eventObject.data = packet.data || {};
+                eventObject.data.data = newData;
             }
             else {
-                newData = packet.data;
+                eventObject.data = newData;
             }
-            if (packet.options && useCache && packet.options.stringifiedData != null && !this.isBufferingBatch) {
+            this.sendObject(eventObject);
+        }
+    }
+    async _invoke({ event, data, options }) {
+        options = options || {};
+        return new Promise((resolve, reject) => {
+            const eventObject = {
+                event,
+                cid: this._nextCallId()
+            };
+            if (data !== undefined) {
+                eventObject.data = data;
+            }
+            const ackTimeout = options.ackTimeout == null ? this.server.ackTimeout : options.ackTimeout;
+            const timeout = setTimeout(() => {
+                let error = new TimeoutError(`Event response for ${event} event timed out`);
+                delete this._callbackMap[eventObject.cid];
+                reject(error);
+            }, ackTimeout);
+            this._callbackMap[eventObject.cid] = {
+                event,
+                callback: (err, result) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(result);
+                },
+                timeout
+            };
+            if (options.useCache && options.stringifiedData != null && !this.isBufferingBatch) {
                 // Optimized
-                this.send(packet.options.stringifiedData);
+                this.send(options.stringifiedData);
             }
             else {
-                const eventObject = {
-                    event: packet.event
-                };
-                if (isPublishOutPacket(packet)) {
-                    eventObject.data = packet.data || {};
-                    eventObject.data.data = newData;
-                }
-                else {
-                    eventObject.data = newData;
-                }
                 this.sendObject(eventObject);
             }
         });
     }
-    _invoke({ event, data, options }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            options = options || {};
-            return new Promise((resolve, reject) => {
-                const eventObject = {
-                    event,
-                    cid: this._nextCallId()
-                };
-                if (data !== undefined) {
-                    eventObject.data = data;
-                }
-                const ackTimeout = options.ackTimeout == null ? this.server.ackTimeout : options.ackTimeout;
-                const timeout = setTimeout(() => {
-                    let error = new TimeoutError(`Event response for "${event}" timed out`);
-                    delete this._callbackMap[eventObject.cid];
-                    reject(error);
-                }, ackTimeout);
-                this._callbackMap[eventObject.cid] = {
-                    event,
-                    callback: (err, result) => {
-                        if (err) {
-                            reject(err);
-                            return;
-                        }
-                        resolve(result);
-                    },
-                    timeout
-                };
-                if (options.useCache && options.stringifiedData != null && !this.isBufferingBatch) {
-                    // Optimized
-                    this.send(options.stringifiedData);
-                }
-                else {
-                    this.sendObject(eventObject);
-                }
-            });
-        });
-    }
     triggerAuthenticationEvents(oldAuthState) {
         if (oldAuthState !== AuthState.AUTHENTICATED) {
             let stateChangeData = {
@@ -1050,7 +972,10 @@ export class ServerSocket extends AsyncStreamEmitter {
                 authToken: this.authToken
             };
             this.emit('authStateChange', stateChangeData);
-            this.server.emit('authenticationStateChange', Object.assign({ socket: this }, stateChangeData));
+            this.server.emit('authenticationStateChange', {
+                socket: this,
+                ...stateChangeData
+            });
         }
         this.emit('authenticate', { authToken: this.authToken });
         this.server.emit('authentication', {
@@ -1058,87 +983,91 @@ export class ServerSocket extends AsyncStreamEmitter {
             authToken: this.authToken
         });
     }
-    setAuthToken(data, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.state === SocketState.CONNECTING) {
-                const err = new InvalidActionError('Cannot call setAuthToken before completing the handshake');
+    async setAuthToken(data, options) {
+        if (this.state === SocketState.CONNECTING) {
+            const err = new InvalidActionError('Cannot call setAuthToken before completing the handshake');
+            this.emitError(err);
+            throw err;
+        }
+        const authToken = cloneDeep(data);
+        const oldAuthState = this.authState;
+        this.authState = AuthState.AUTHENTICATED;
+        if (options == null) {
+            options = {};
+        }
+        else {
+            options = { ...options };
+            if (options.algorithm != null) {
+                delete options.algorithm;
+                let err = new InvalidArgumentsError('Cannot change auth token algorithm at runtime - It must be specified as a config option on launch');
                 this.emitError(err);
-                throw err;
             }
-            const authToken = cloneDeep(data);
-            const oldAuthState = this.authState;
-            this.authState = AuthState.AUTHENTICATED;
-            if (options == null) {
-                options = {};
+        }
+        options.mutatePayload = true;
+        const rejectOnFailedDelivery = options.rejectOnFailedDelivery;
+        delete options.rejectOnFailedDelivery;
+        const defaultSignatureOptions = this.server.defaultSignatureOptions;
+        // We cannot have the exp claim on the token and the expiresIn option
+        // set at the same time or else auth.signToken will throw an error.
+        let expiresIn;
+        if (options.expiresIn == null) {
+            expiresIn = defaultSignatureOptions.expiresIn;
+        }
+        else {
+            expiresIn = options.expiresIn;
+        }
+        if (authToken) {
+            if (authToken.exp == null) {
+                options.expiresIn = expiresIn;
             }
             else {
-                options = Object.assign({}, options);
-                if (options.algorithm != null) {
-                    delete options.algorithm;
-                    let err = new InvalidArgumentsError('Cannot change auth token algorithm at runtime - It must be specified as a config option on launch');
-                    this.emitError(err);
-                }
-            }
-            options.mutatePayload = true;
-            const rejectOnFailedDelivery = options.rejectOnFailedDelivery;
-            delete options.rejectOnFailedDelivery;
-            const defaultSignatureOptions = this.server.defaultSignatureOptions;
-            // We cannot have the exp claim on the token and the expiresIn option
-            // set at the same time or else auth.signToken will throw an error.
-            let expiresIn;
-            if (options.expiresIn == null) {
-                expiresIn = defaultSignatureOptions.expiresIn;
+                delete options.expiresIn;
             }
-            else {
-                expiresIn = options.expiresIn;
+        }
+        else {
+            options.expiresIn = expiresIn;
+        }
+        // Always use the default algorithm since it cannot be changed at runtime.
+        if (defaultSignatureOptions.algorithm != null) {
+            options.algorithm = defaultSignatureOptions.algorithm;
+        }
+        this.authToken = authToken;
+        let signedAuthToken;
+        try {
+            signedAuthToken = await this.server.auth.signToken(authToken, this.server.signatureKey, options);
+        }
+        catch (error) {
+            this.emitError(error);
+            this._destroy(4002, error.toString());
+            this.socket.close(4002);
+            throw error;
+        }
+        if (this.authToken === authToken) {
+            this.signedAuthToken = signedAuthToken;
+            this.emit('authTokenSigned', { signedAuthToken });
+        }
+        this.triggerAuthenticationEvents(oldAuthState);
+        const tokenData = {
+            token: signedAuthToken
+        };
+        if (rejectOnFailedDelivery) {
+            try {
+                await this.invoke('#setAuthToken', tokenData);
             }
-            if (authToken) {
-                if (authToken.exp == null) {
-                    options.expiresIn = expiresIn;
+            catch (err) {
+                let error;
+                if (err && typeof err.message === 'string') {
+                    error = new AuthError(`Failed to deliver auth token to client - ${err.message}`);
                 }
                 else {
-                    delete options.expiresIn;
+                    error = new AuthError('Failed to confirm delivery of auth token to client due to malformatted error response');
                 }
-            }
-            else {
-                options.expiresIn = expiresIn;
-            }
-            // Always use the default algorithm since it cannot be changed at runtime.
-            if (defaultSignatureOptions.algorithm != null) {
-                options.algorithm = defaultSignatureOptions.algorithm;
-            }
-            this.authToken = authToken;
-            let signedAuthToken;
-            try {
-                signedAuthToken = yield this.server.auth.signToken(authToken, this.server.signatureKey, options);
-            }
-            catch (error) {
                 this.emitError(error);
-                this._destroy(4002, error.toString());
-                this.socket.close(4002);
                 throw error;
             }
-            if (this.authToken === authToken) {
-                this.signedAuthToken = signedAuthToken;
-                this.emit('authTokenSigned', { signedAuthToken });
-            }
-            this.triggerAuthenticationEvents(oldAuthState);
-            const tokenData = {
-                token: signedAuthToken
-            };
-            if (rejectOnFailedDelivery) {
-                try {
-                    yield this.invoke('#setAuthToken', tokenData);
-                }
-                catch (err) {
-                    const error = new AuthError(`Failed to deliver auth token to client - ${err}`);
-                    this.emitError(error);
-                    throw error;
-                }
-                return;
-            }
-            this.transmit('#setAuthToken', tokenData);
-        });
+            return;
+        }
+        this.transmit('#setAuthToken', tokenData);
     }
     getAuthToken() {
         return this.authToken;
@@ -1155,7 +1084,10 @@ export class ServerSocket extends AsyncStreamEmitter {
                 newAuthState: this.authState
             };
             this.emit('authStateChange', stateChangeData);
-            this.server.emit('authenticationStateChange', Object.assign({ socket: this }, stateChangeData));
+            this.server.emit('authenticationStateChange', {
+                socket: this,
+                ...stateChangeData
+            });
         }
         this.emit('deauthenticate', { oldAuthToken });
         this.server.emit('deauthentication', {
@@ -1163,23 +1095,21 @@ export class ServerSocket extends AsyncStreamEmitter {
             oldAuthToken
         });
     }
-    deauthenticate(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.deauthenticateSelf();
-            if (options && options.rejectOnFailedDelivery) {
-                try {
-                    yield this.invoke('#removeAuthToken');
-                }
-                catch (error) {
-                    this.emitError(error);
-                    if (options && options.rejectOnFailedDelivery) {
-                        throw error;
-                    }
+    async deauthenticate(options) {
+        this.deauthenticateSelf();
+        if (options && options.rejectOnFailedDelivery) {
+            try {
+                await this.invoke('#removeAuthToken');
+            }
+            catch (error) {
+                this.emitError(error);
+                if (options && options.rejectOnFailedDelivery) {
+                    throw error;
                 }
-                return;
             }
-            this._transmit('#removeAuthToken');
-        });
+            return;
+        }
+        this._transmit('#removeAuthToken');
     }
     kickOut(channel, message) {
         const channels = channel ? [channel] : Object.keys(this.channelSubscriptions);
@@ -1203,7 +1133,7 @@ export class ServerSocket extends AsyncStreamEmitter {
         return null;
     }
     isAuthTokenExpired(token) {
-        if ((token === null || token === void 0 ? void 0 : token.exp) != null) {
+        if (token?.exp != null) {
             const currentTime = Date.now();
             const expiryMilliseconds = token.exp * 1000;
             return currentTime > expiryMilliseconds;
@@ -1234,61 +1164,57 @@ export class ServerSocket extends AsyncStreamEmitter {
             signedAuthToken
         });
     }
-    _validateAuthToken(signedAuthToken) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const verificationOptions = Object.assign({}, this.server.defaultVerificationOptions);
-            let authToken;
-            try {
-                authToken = yield this.server.auth.verifyToken(signedAuthToken, this.server.verificationKey, verificationOptions);
-            }
-            catch (error) {
-                const authTokenError = this._processTokenError(error);
-                return {
-                    signedAuthToken,
-                    authTokenError,
-                    authToken: null,
-                    authState: AuthState.UNAUTHENTICATED
-                };
-            }
+    async _validateAuthToken(signedAuthToken) {
+        const verificationOptions = Object.assign({ socket: this }, this.server.defaultVerificationOptions);
+        let authToken;
+        try {
+            authToken = await this.server.auth.verifyToken(signedAuthToken, this.server.verificationKey, verificationOptions);
+        }
+        catch (error) {
+            const authTokenError = this._processTokenError(error);
             return {
                 signedAuthToken,
-                authTokenError: null,
-                authToken,
-                authState: AuthState.AUTHENTICATED
+                authTokenError,
+                authToken: null,
+                authState: AuthState.UNAUTHENTICATED
             };
-        });
+        }
+        return {
+            signedAuthToken,
+            authTokenError: null,
+            authToken,
+            authState: AuthState.AUTHENTICATED
+        };
     }
-    _processAuthentication({ signedAuthToken, authTokenError, authToken }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (authTokenError) {
-                this.signedAuthToken = null;
-                this.authToken = null;
-                this.authState = AuthState.UNAUTHENTICATED;
-                // If the error is related to the JWT being badly formatted, then we will
-                // treat the error as a socket error.
-                if (signedAuthToken != null) {
-                    this.emitError(authTokenError);
-                    if (authTokenError instanceof AuthTokenError) {
-                        this._emitBadAuthTokenError(authTokenError, signedAuthToken);
-                    }
+    async _processAuthentication({ signedAuthToken, authTokenError, authToken }) {
+        if (authTokenError) {
+            this.signedAuthToken = null;
+            this.authToken = null;
+            this.authState = AuthState.UNAUTHENTICATED;
+            // If the error is related to the JWT being badly formatted, then we will
+            // treat the error as a socket error.
+            if (signedAuthToken != null) {
+                this.emitError(authTokenError);
+                if (authTokenError instanceof AuthTokenError) {
+                    this._emitBadAuthTokenError(authTokenError, signedAuthToken);
                 }
-                throw authTokenError;
-            }
-            this.signedAuthToken = signedAuthToken;
-            this.authToken = authToken;
-            this.authState = AuthState.AUTHENTICATED;
-            const action = new ActionAuthenticate(this, authToken, signedAuthToken);
-            try {
-                yield this.server._processMiddlewareAction(this.middlewareInboundStream, action, this);
             }
-            catch (error) {
-                this.authToken = null;
-                this.authState = AuthState.UNAUTHENTICATED;
-                if (error instanceof AuthTokenError) {
-                    this._emitBadAuthTokenError(error, signedAuthToken);
-                }
-                throw error;
+            throw authTokenError;
+        }
+        this.signedAuthToken = signedAuthToken;
+        this.authToken = authToken;
+        this.authState = AuthState.AUTHENTICATED;
+        const action = new ActionAuthenticate(this, authToken, signedAuthToken);
+        try {
+            await this.server._processMiddlewareAction(this.middlewareInboundStream, action, this);
+        }
+        catch (error) {
+            this.authToken = null;
+            this.authState = AuthState.UNAUTHENTICATED;
+            if (error instanceof AuthTokenError) {
+                this._emitBadAuthTokenError(error, signedAuthToken);
             }
-        });
+            throw error;
+        }
     }
 }