@socket-mesh/server 18.0.6 → 18.1.1

package/serversocket.js

@@ -1,1262 +0,0 @@
-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, 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.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 { RemoteProcedure } from './remote-procedure.js';
-const HANDSHAKE_REJECTION_STATUS_CODE = 4008;
-export class ServerSocket extends AsyncStreamEmitter {
-    authState;
-    authToken;
-    batchInterval;
-    batchOnHandshake;
-    batchOnHandshakeDuration;
-    cloneData;
-    channelSubscriptionsCount;
-    inboundReceivedMessageCount;
-    inboundProcessedMessageCount;
-    isBatching;
-    isBufferingBatch;
-    request;
-    id;
-    socket;
-    protocolVersion;
-    channelSubscriptions;
-    inboundMessageStream;
-    outboundPacketStream;
-    server;
-    middlewareHandshakeStream;
-    middlewareInboundRawStream;
-    middlewareInboundStream;
-    middlewareOutboundStream;
-    remoteAddress;
-    remoteFamily;
-    remotePort;
-    outboundPreparedMessageCount;
-    outboundSentMessageCount;
-    signedAuthToken;
-    state;
-    receiver;
-    procedure;
-    _cid;
-    _handshakeTimeoutRef;
-    _pingIntervalTicker;
-    _pingTimeoutTicker;
-    _batchBuffer;
-    _batchingIntervalId;
-    _callbackMap;
-    _receiverDemux;
-    _procedureDemux;
-    _sendPing;
-    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 RemoteProcedure(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', async (messageBuffer, isBinary) => {
-            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 } = await 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());
-    }
-    get exchange() {
-        return this.server.exchange;
-    }
-    getInboundBackpressure() {
-        return this.inboundReceivedMessageCount - this.inboundProcessedMessageCount;
-    }
-    getOutboundBackpressure() {
-        return this.outboundPreparedMessageCount - this.outboundSentMessageCount;
-    }
-    _startBatchOnHandshake() {
-        this._startBatching();
-        setTimeout(() => {
-            if (!this.isBatching) {
-                this._stopBatching();
-            }
-        }, this.batchOnHandshakeDuration);
-    }
-    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;
-                }
-                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++) {
-                    await this._processInboundPacket(packet[i], message);
-                }
-            }
-            else {
-                await this._processInboundPacket(packet, message);
-            }
-        }
-    }
-    _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;
-            }
-            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();
-                }
-            }
-        }
-        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;
-            }
-            request.end({
-                isAuthenticated: !!this.authToken,
-                authError: signedAuthToken == null ? null : dehydrateError(error)
-            });
-            return;
-        }
-        this.triggerAuthenticationEvents(oldAuthState);
-        request.end({
-            isAuthenticated: !!this.authToken,
-            authError: null
-        });
-    }
-    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
-        });
-    }
-    async _processSubscribeRequest(request) {
-        if (this.state === SocketState.OPEN) {
-            let subscriptionOptions = Object.assign({}, request.data);
-            let channelName = subscriptionOptions.channel;
-            delete subscriptionOptions.channel;
-            try {
-                await 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);
-    }
-    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);
-        }
-    }
-    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;
-            }
-            if (this.server.strictHandshake && this.state === SocketState.CONNECTING) {
-                this._destroy(4009);
-                this.socket.close(4009);
-                return;
-            }
-            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;
-                }
-                // 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 (isRPC) {
-                    const request = new UnsubscribeRequest(this, packet.cid, packet.event, packet.data);
-                    await this._processUnsubscribeRequest(request);
-                    this._procedureDemux.write(request.procedure, request);
-                    return;
-                }
-                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 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);
-                    }
-                    return;
-                }
-                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;
-                }
-                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 } = await this.server._processMiddlewareAction(this.middlewareInboundStream, action, this);
-                    newData = data;
-                }
-                catch (error) {
-                    this.sendObject(createErrorResponse(packet.cid, error));
-                    return;
-                }
-                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);
-                    }
-                }
-                else {
-                    request = new RequestWithResponse(this, packet.cid, packet.event, newData);
-                }
-                this._procedureDemux.write(request.procedure, request);
-                return;
-            }
-            try {
-                let { data } = await this.server._processMiddlewareAction(this.middlewareInboundStream, action, this);
-                newData = data;
-            }
-            catch (error) {
-                return;
-            }
-            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;
-        }
-        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();
-    }
-    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 {
-                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 {
-                    closeMessage = `Socket connection closed with status code ${code}`;
-                }
-                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;
-        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);
-        }
-    }
-    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 {
-                        result = await this._invoke(packet);
-                    }
-                    catch (error) {
-                        packet.reject(error);
-                        return;
-                    }
-                    packet.resolve(result);
-                })();
-                this.outboundSentMessageCount++;
-                continue;
-            }
-            await this._processTransmit(packet);
-            this.outboundSentMessageCount++;
-        }
-    }
-    _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} event was aborted due to a bad connection`, 'connectAbort');
-            this.emitError(error);
-            return;
-        }
-        this._transmit(event, data, options);
-    }
-    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
-            });
-        });
-    }
-    emit(eventName, data) {
-        super.emit(eventName, data);
-    }
-    listen(eventName) {
-        return super.listen(eventName);
-    }
-    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)) {
-                eventObject.data = packet.data || {};
-                eventObject.data.data = newData;
-            }
-            else {
-                eventObject.data = newData;
-            }
-            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(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', {
-                socket: this,
-                ...stateChangeData
-            });
-        }
-        this.emit('authenticate', { authToken: this.authToken });
-        this.server.emit('authentication', {
-            socket: this,
-            authToken: this.authToken
-        });
-    }
-    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);
-            }
-        }
-        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 = 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);
-            }
-            catch (err) {
-                let error;
-                if (err && typeof err.message === 'string') {
-                    error = new AuthError(`Failed to deliver auth token to client - ${err.message}`);
-                }
-                else {
-                    error = new AuthError('Failed to confirm delivery of auth token to client due to malformatted error response');
-                }
-                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', {
-                socket: this,
-                ...stateChangeData
-            });
-        }
-        this.emit('deauthenticate', { oldAuthToken });
-        this.server.emit('deauthentication', {
-            socket: this,
-            oldAuthToken
-        });
-    }
-    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');
-    }
-    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?.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
-        });
-    }
-    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,
-                authToken: null,
-                authState: AuthState.UNAUTHENTICATED
-            };
-        }
-        return {
-            signedAuthToken,
-            authTokenError: null,
-            authToken,
-            authState: AuthState.AUTHENTICATED
-        };
-    }
-    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 {
-            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;
-        }
-    }
-}