@socket-mesh/server 17.3.1

package/serversocket.js

@@ -0,0 +1,1294 @@
+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 { 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';
+const HANDSHAKE_REJECTION_STATUS_CODE = 4008;
+export class ServerSocket extends AsyncStreamEmitter {
+    constructor(id, server, socket, protocolVersion) {
+        super();
+        this.id = id;
+        this.server = server;
+        this.socket = socket;
+        this.state = SocketState.CONNECTING;
+        this.authState = AuthState.UNAUTHENTICATED;
+        this.protocolVersion = protocolVersion;
+        this._receiverDemux = new StreamDemux();
+        this.receiver = new StreamDemuxWrapper(this._receiverDemux);
+        this._procedureDemux = new StreamDemux();
+        this.procedure = new StreamDemuxWrapper(this._procedureDemux);
+        this.request = this.socket.upgradeReq;
+        this.inboundReceivedMessageCount = 0;
+        this.inboundProcessedMessageCount = 0;
+        this.outboundPreparedMessageCount = 0;
+        this.outboundSentMessageCount = 0;
+        this.cloneData = this.server.options.cloneData;
+        this.inboundMessageStream = new WritableConsumableStream();
+        this.outboundPacketStream = new WritableConsumableStream();
+        this.middlewareHandshakeStream = this.request['handshakeStream'];
+        this.middlewareInboundRawStream = new MiddlewareStream(MiddlewareType.MIDDLEWARE_INBOUND_RAW);
+        this.middlewareInboundStream = new MiddlewareStream(MiddlewareType.MIDDLEWARE_INBOUND);
+        this.middlewareOutboundStream = new MiddlewareStream(MiddlewareType.MIDDLEWARE_OUTBOUND);
+        if (this.request.socket) {
+            this.remoteAddress = this.request.socket.remoteAddress;
+            this.remoteFamily = this.request.socket.remoteFamily;
+            this.remotePort = this.request.socket.remotePort;
+        }
+        // else {
+        //	this.remoteAddress = this.request.remoteAddress;
+        //	this.remoteFamily = this.request.remoteFamily;
+        //	this.remotePort = this.request.remotePort;
+        //}
+        //		if (this.request.forwardedForAddress) {
+        //			this.forwardedForAddress = this.request.forwardedForAddress;
+        //		}
+        this.isBufferingBatch = false;
+        this.isBatching = false;
+        this.batchOnHandshake = this.server.options.batchOnHandshake;
+        this.batchOnHandshakeDuration = this.server.options.batchOnHandshakeDuration;
+        this.batchInterval = this.server.options.batchInterval;
+        this._batchBuffer = [];
+        this._batchingIntervalId = null;
+        this._cid = 1;
+        this._callbackMap = {};
+        this.channelSubscriptions = {};
+        this.channelSubscriptionsCount = 0;
+        this.socket.on('error', (err) => {
+            this.emitError(err);
+        });
+        this.socket.on('close', (code, reasonBuffer) => {
+            let reason = reasonBuffer.toString();
+            this._destroy(code, reason);
+        });
+        let pongMessage;
+        if (this.protocolVersion === 1) {
+            pongMessage = '#2';
+            this._sendPing = () => {
+                if (this.state !== SocketState.CLOSED) {
+                    this.send('#1');
+                }
+            };
+        }
+        else {
+            pongMessage = '';
+            this._sendPing = () => {
+                if (this.state !== SocketState.CLOSED) {
+                    this.send('');
+                }
+            };
+        }
+        if (!this.server.pingTimeoutDisabled) {
+            this._pingIntervalTicker = setInterval(() => {
+                this._sendPing();
+            }, this.server.pingInterval);
+        }
+        this._resetPongTimeout();
+        this._handshakeTimeoutRef = setTimeout(() => {
+            this._handleHandshakeTimeout();
+        }, this.server.handshakeTimeout);
+        this.server.pendingClients[this.id] = this;
+        this.server.pendingClientsCount++;
+        this._handleInboundMessageStream(pongMessage);
+        this._handleOutboundPacketStream();
+        // Receive incoming raw messages
+        this.socket.on('message', (messageBuffer, isBinary) => __awaiter(this, void 0, void 0, function* () {
+            let message = isBinary ? messageBuffer : messageBuffer.toString();
+            this.inboundReceivedMessageCount++;
+            let isPong = message === pongMessage;
+            if (isPong) {
+                this._resetPongTimeout();
+            }
+            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);
+                    message = data;
+                }
+                catch (error) {
+                    this.inboundProcessedMessageCount++;
+                    return;
+                }
+            }
+            this.inboundMessageStream.write(message);
+            this.emit('message', { message });
+        }));
+    }
+    getBackpressure() {
+        return Math.max(this.getInboundBackpressure(), this.getOutboundBackpressure(), this.getListenerBackpressure(), this.receiver.getBackpressure(), this.procedure.getBackpressure());
+    }
+    ;
+    getInboundBackpressure() {
+        return this.inboundReceivedMessageCount - this.inboundProcessedMessageCount;
+    }
+    ;
+    getOutboundBackpressure() {
+        return this.outboundPreparedMessageCount - this.outboundSentMessageCount;
+    }
+    ;
+    _startBatchOnHandshake() {
+        this._startBatching();
+        setTimeout(() => {
+            if (!this.isBatching) {
+                this._stopBatching();
+            }
+        }, 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;
+                    }
+                }
+            }
+            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; }
+            }
+        });
+    }
+    ;
+    _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);
+            try {
+                yield this.server._processMiddlewareAction(this.middlewareHandshakeStream, action);
+            }
+            catch (error) {
+                if (error.statusCode == null) {
+                    error.statusCode = HANDSHAKE_REJECTION_STATUS_CODE;
+                }
+                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;
+                }
+            }
+            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();
+                    }
+                }
+            }
+            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();
+            }
+            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);
+            }
+            catch (error) {
+                if (error instanceof AuthTokenError) {
+                    this.deauthenticate();
+                    request.error(error);
+                    return;
+                }
+                request.end({
+                    isAuthenticated: !!this.authToken,
+                    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
+            });
+        });
+    }
+    ;
+    _processSubscribeRequest(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 });
+            }
+            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}`);
+                this.emitError(error);
+                request.error(error);
+                return;
+            }
+            request.end();
+        });
+    }
+    _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);
+            }
+        });
+    }
+    _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);
+                return;
+            }
+            try {
+                yield this.server.exchange.invokePublish(data.channel, data.data);
+            }
+            catch (error) {
+                this.emitError(error);
+                request.error(error);
+                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);
+                    return;
+                }
+                if (this.server.strictHandshake && this.state === SocketState.CONNECTING) {
+                    this._destroy(4009);
+                    this.socket.close(4009);
+                    return;
+                }
+                if (isAuthenticatePacket(packet)) {
+                    // Let AGServer handle these events.
+                    const request = new AuthenticateRequest(this, packet.cid, packet.event, packet.data);
+                    yield 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 (isRPC) {
+                        const request = new UnsubscribeRequest(this, packet.cid, packet.event, packet.data);
+                        yield this._processUnsubscribeRequest(request);
+                        this._procedureDemux.write(request.procedure, request);
+                        return;
+                    }
+                    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;
+                    }
+                    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;
+                }
+                let newData;
+                if (isRPC) {
+                    let request = new Request(this, packet.cid, packet.event, packet.data);
+                    try {
+                        let { data } = yield this.server._processMiddlewareAction(this.middlewareInboundStream, action, this);
+                        newData = data;
+                    }
+                    catch (error) {
+                        request.error(error);
+                        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;
+                }
+                try {
+                    let { data } = yield this.server._processMiddlewareAction(this.middlewareInboundStream, action, this);
+                    newData = data;
+                }
+                catch (error) {
+                    return;
+                }
+                if (isPublishPacket(packet)) {
+                    if (!packet.data) {
+                        packet.data = {};
+                    }
+                    packet.data.data = newData;
+                    yield 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) {
+                // 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;
+        }
+        clearTimeout(this._pingTimeoutTicker);
+        this._pingTimeoutTicker = setTimeout(() => {
+            this._destroy(4001);
+            this.socket.close(4001);
+        }, this.server.pingTimeout);
+    }
+    _nextCallId() {
+        return this._cid++;
+    }
+    getState() {
+        return this.state;
+    }
+    getBytesReceived() {
+        return this.socket.bytesReceived;
+    }
+    emitError(error) {
+        this.emit('error', { error });
+        this.server.emitWarning(error);
+    }
+    _abortAllPendingEventsDueToBadConnection(failureType) {
+        Object.keys(this._callbackMap || {}).forEach((i) => {
+            const eventObject = this._callbackMap[i];
+            delete this._callbackMap[i];
+            clearTimeout(eventObject.timeout);
+            delete eventObject.timeout;
+            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;
+            callback.call(eventObject, badConnectionError, eventObject);
+        });
+    }
+    closeAllMiddlewares() {
+        this.middlewareHandshakeStream.close();
+        this.middlewareInboundRawStream.close();
+        this.middlewareInboundStream.close();
+        this.middlewareOutboundStream.close();
+    }
+    closeInput() {
+        this.inboundMessageStream.close();
+    }
+    closeOutput() {
+        this.outboundPacketStream.close();
+    }
+    closeIO() {
+        this.closeInput();
+        this.closeOutput();
+    }
+    closeAllStreams() {
+        this.closeAllMiddlewares();
+        this.closeIO();
+        this.receiver.close();
+        this.procedure.close();
+        this.closeListeners();
+    }
+    killAllMiddlewares() {
+        this.middlewareHandshakeStream.kill();
+        this.middlewareInboundRawStream.kill();
+        this.middlewareInboundStream.kill();
+        this.middlewareOutboundStream.kill();
+    }
+    killInput() {
+        this.inboundMessageStream.kill();
+    }
+    killOutput() {
+        this.outboundPacketStream.kill();
+    }
+    killIO() {
+        this.killInput();
+        this.killOutput();
+    }
+    killAllStreams() {
+        this.killAllMiddlewares();
+        this.killIO();
+        this.receiver.kill();
+        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) {
+                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 {
+                    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 (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');
+            }
+        });
+    }
+    disconnect(code, reason) {
+        code = code || 1000;
+        if (typeof code !== 'number') {
+            let err = new InvalidArgumentsError('If specified, the code argument must be a number');
+            this.emitError(err);
+        }
+        if (this.state !== SocketState.CLOSED) {
+            this._destroy(code, reason);
+            this.socket.close(code, reason);
+        }
+    }
+    terminate() {
+        this.socket.terminate();
+    }
+    send(data, options) {
+        const cb = (error) => {
+            if (error) {
+                this.emitError(error);
+                this._destroy(1006, error.toString());
+            }
+        };
+        if (options) {
+            this.socket.send(data, options, cb);
+        }
+        else {
+            this.socket.send(data, cb);
+        }
+    }
+    decode(message) {
+        return this.server.codec.decode(message);
+    }
+    encode(object) {
+        return this.server.codec.encode(object);
+    }
+    startBatch() {
+        this.isBufferingBatch = true;
+        this._batchBuffer = [];
+    }
+    flushBatch() {
+        this.isBufferingBatch = false;
+        if (!this._batchBuffer.length) {
+            return;
+        }
+        let serializedBatch = this.serializeObject(this._batchBuffer);
+        this._batchBuffer = [];
+        this.send(serializedBatch);
+    }
+    cancelBatch() {
+        this.isBufferingBatch = false;
+        this._batchBuffer = [];
+    }
+    _startBatching() {
+        if (this._batchingIntervalId != null) {
+            return;
+        }
+        this.startBatch();
+        this._batchingIntervalId = setInterval(() => {
+            this.flushBatch();
+            this.startBatch();
+        }, this.batchInterval);
+    }
+    startBatching() {
+        this.isBatching = true;
+        this._startBatching();
+    }
+    _stopBatching() {
+        if (this._batchingIntervalId != null) {
+            clearInterval(this._batchingIntervalId);
+        }
+        this._batchingIntervalId = null;
+        this.flushBatch();
+    }
+    stopBatching() {
+        this.isBatching = false;
+        this._stopBatching();
+    }
+    _cancelBatching() {
+        if (this._batchingIntervalId != null) {
+            clearInterval(this._batchingIntervalId);
+        }
+        this._batchingIntervalId = null;
+        this.cancelBatch();
+    }
+    cancelBatching() {
+        this.isBatching = false;
+        this._cancelBatching();
+    }
+    ;
+    serializeObject(object) {
+        let str;
+        try {
+            str = this.encode(object);
+        }
+        catch (error) {
+            this.emitError(error);
+            return null;
+        }
+        return str;
+    }
+    ;
+    sendObject(object) {
+        if (this.isBufferingBatch) {
+            this._batchBuffer.push(object);
+            return;
+        }
+        let str = this.serializeObject(object);
+        if (str != null) {
+            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;
+                    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++;
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            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; }
+            }
+        });
+    }
+    _transmit(event, data, options) {
+        if (this.cloneData) {
+            data = cloneDeep(data);
+        }
+        this.outboundPreparedMessageCount++;
+        this.outboundPacketStream.write({
+            event,
+            data,
+            options
+        });
+    }
+    transmit(event, data, options) {
+        if (this.state !== SocketState.OPEN) {
+            let error = new BadConnectionError(`Socket transmit "${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
+                });
+            });
+        });
+    }
+    emit(eventName, data) {
+        super.emit(eventName, data);
+    }
+    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;
+            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;
+                }
+            }
+            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)) {
+                    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 = {
+                oldAuthState,
+                newAuthState: this.authState,
+                authToken: this.authToken
+            };
+            this.emit('authStateChange', stateChangeData);
+            this.server.emit('authenticationStateChange', Object.assign({ socket: this }, stateChangeData));
+        }
+        this.emit('authenticate', { authToken: this.authToken });
+        this.server.emit('authentication', {
+            socket: this,
+            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');
+                this.emitError(err);
+                throw err;
+            }
+            const authToken = cloneDeep(data);
+            const oldAuthState = this.authState;
+            this.authState = AuthState.AUTHENTICATED;
+            if (options == null) {
+                options = {};
+            }
+            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;
+            }
+            else {
+                expiresIn = options.expiresIn;
+            }
+            if (authToken) {
+                if (authToken.exp == null) {
+                    options.expiresIn = expiresIn;
+                }
+                else {
+                    delete 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 = 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);
+        });
+    }
+    getAuthToken() {
+        return this.authToken;
+    }
+    deauthenticateSelf() {
+        const oldAuthState = this.authState;
+        const oldAuthToken = this.authToken;
+        this.signedAuthToken = null;
+        this.authToken = null;
+        this.authState = AuthState.UNAUTHENTICATED;
+        if (oldAuthState !== AuthState.UNAUTHENTICATED) {
+            const stateChangeData = {
+                oldAuthState,
+                newAuthState: this.authState
+            };
+            this.emit('authStateChange', stateChangeData);
+            this.server.emit('authenticationStateChange', Object.assign({ socket: this }, stateChangeData));
+        }
+        this.emit('deauthenticate', { oldAuthToken });
+        this.server.emit('deauthentication', {
+            socket: this,
+            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;
+                    }
+                }
+                return;
+            }
+            this._transmit('#removeAuthToken');
+        });
+    }
+    kickOut(channel, message) {
+        const channels = channel ? [channel] : Object.keys(this.channelSubscriptions);
+        return Promise.all(channels.map((channelName) => {
+            this.transmit('#kickOut', { channel: channelName, message });
+            return this._unsubscribe(channelName);
+        }));
+    }
+    subscriptions() {
+        return Object.keys(this.channelSubscriptions);
+    }
+    isSubscribed(channel) {
+        return !!this.channelSubscriptions[channel];
+    }
+    _processAuthTokenExpiry() {
+        const token = this.getAuthToken();
+        if (this.isAuthTokenExpired(token)) {
+            this.deauthenticate();
+            return new AuthTokenExpiredError('The socket auth token has expired', new Date(token.exp));
+        }
+        return null;
+    }
+    isAuthTokenExpired(token) {
+        if ((token === null || token === void 0 ? void 0 : token.exp) != null) {
+            const currentTime = Date.now();
+            const expiryMilliseconds = token.exp * 1000;
+            return currentTime > expiryMilliseconds;
+        }
+        return false;
+    }
+    _processTokenError(err) {
+        if (err.name === 'TokenExpiredError' && 'expiredAt' in err) {
+            return new AuthTokenExpiredError(err.message, err.expiredAt);
+        }
+        if (err.name === 'JsonWebTokenError') {
+            return new AuthTokenInvalidError(err.message);
+        }
+        if (err.name === 'NotBeforeError' && 'date' in err) {
+            // In this case, the token is good; it's just not active yet.
+            return new AuthTokenNotBeforeError(err.message, err.date);
+        }
+        return new AuthTokenError(err.message);
+    }
+    _emitBadAuthTokenError(error, signedAuthToken) {
+        this.emit('badAuthToken', {
+            authError: error,
+            signedAuthToken
+        });
+        this.server.emit('badSocketAuthToken', {
+            socket: this,
+            authError: error,
+            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
+                };
+            }
+            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);
+                    }
+                }
+                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;
+            }
+        });
+    }
+}