@socket-mesh/core 1.0.3 → 2.0.0

package/dist/socket-transport.js

@@ -1,15 +1,37 @@
-import defaultCodec from "@socket-mesh/formatter";
-import ws from "isomorphic-ws";
-import { abortRequest, isRequestDone } from "./request.js";
-import { isRequestPacket } from "./packet.js";
-import { AbortError, BadConnectionError, InvalidActionError, InvalidArgumentsError, PluginBlockedError, SocketProtocolError, TimeoutError, dehydrateError, hydrateError, socketProtocolErrorStatuses, socketProtocolIgnoreStatuses } from "@socket-mesh/errors";
-import { isResponsePacket } from "./response.js";
-import { extractAuthTokenData } from "@socket-mesh/auth";
-import { RequestHandlerArgs } from "./request-handler.js";
-import { toArray, wait } from "./utils.js";
-export class SocketTransport {
+import { extractAuthTokenData } from '@socket-mesh/auth';
+import { AbortError, AuthError, BadConnectionError, dehydrateError, hydrateError, InvalidActionError, InvalidArgumentsError, PluginBlockedError, SocketClosedError, SocketProtocolError, SocketProtocolErrorStatuses, SocketProtocolIgnoreStatuses, TimeoutError } from '@socket-mesh/errors';
+import defaultCodec from '@socket-mesh/formatter';
+import ws from 'isomorphic-ws';
+import { isRequestPacket } from './packet.js';
+import { RequestHandlerArgs } from './request-handler.js';
+import { abortRequest, isRequestDone } from './request.js';
+import { isResponsePacket } from './response.js';
+import { toArray, toError, wait } from './utils.js';
+export class BaseSocketTransport {
+    _authToken;
+    _callbackMap;
+    _callIdGenerator;
+    _handlers;
+    _inboundProcessedMessageCount;
+    _inboundReceivedMessageCount;
+    _isReady;
+    _outboundPreparedMessageCount;
+    _outboundSentMessageCount;
+    _pingTimeoutRef;
+    _signedAuthToken;
+    _socket;
+    _webSocket;
+    ackTimeoutMs;
+    codecEngine;
+    id;
+    plugins;
+    streamCleanupMode;
     constructor(options) {
         let cid = 1;
+        this._isReady = false;
+        this._authToken = null;
+        this._signedAuthToken = null;
+        this._webSocket = null;
         this.ackTimeoutMs = options?.ackTimeoutMs ?? 10000;
         this._callIdGenerator = options?.callIdGenerator || (() => {
             return cid++;
@@ -42,10 +64,10 @@ export class SocketTransport {
             const signedAuthToken = this._signedAuthToken;
             this._authToken = null;
             this._signedAuthToken = null;
-            this._socket.emit('authStateChange', { wasAuthenticated: true, isAuthenticated: false });
+            this._socket.emit('authStateChange', { isAuthenticated: false, wasAuthenticated: true });
             // In order for the events to trigger we need to wait for the next tick.
             await wait(0);
-            this._socket.emit('deauthenticate', { signedAuthToken, authToken });
+            this._socket.emit('deauthenticate', { authToken, signedAuthToken });
             for (const plugin of this.plugins) {
                 if (plugin.onDeauthenticate) {
                     plugin.onDeauthenticate({ socket: this.socket, transport: this });
@@ -60,10 +82,11 @@ export class SocketTransport {
             return this.codecEngine.decode(data);
         }
         catch (err) {
-            if (err.name === 'Error') {
-                err.name = 'InvalidMessageError';
+            const error = toError(err);
+            if (error.name === 'Error') {
+                error.name = 'InvalidMessageError';
             }
-            this.onError(err);
+            this.onError(error);
             return null;
         }
     }
@@ -92,14 +115,14 @@ export class SocketTransport {
             try {
                 for (const plugin of this.plugins) {
                     if (plugin.onMessage) {
-                        curPacket = await plugin.onMessage({ socket: this.socket, transport: this, packet: curPacket, timestamp: timestamp });
+                        curPacket = await plugin.onMessage({ packet: curPacket, socket: this.socket, timestamp: timestamp, transport: this });
                     }
                 }
             }
             catch (err) {
-                pluginError = err;
+                pluginError = toError(err);
             }
-            // Check to see if it is a request or response packet. 
+            // Check to see if it is a request or response packet.
             if (isResponsePacket(curPacket)) {
                 this.onResponse(curPacket, pluginError);
             }
@@ -111,19 +134,105 @@ export class SocketTransport {
             }
         }
     }
+    invoke(methodOptions, arg) {
+        let methodRequest;
+        let serviceRequest;
+        let service;
+        let ackTimeoutMs;
+        if (typeof methodOptions === 'object' && !Array.isArray(methodOptions)) {
+            ackTimeoutMs = methodOptions.ackTimeoutMs;
+        }
+        if (typeof methodOptions === 'object' && (Array.isArray(methodOptions) || 'service' in methodOptions)) {
+            let serviceMethod;
+            if (Array.isArray(methodOptions)) {
+                service = methodOptions[0];
+                serviceMethod = methodOptions[1];
+                ackTimeoutMs = methodOptions[2];
+            }
+            else {
+                service = methodOptions.service;
+                serviceMethod = methodOptions.method;
+            }
+            serviceRequest = {
+                ackTimeoutMs: ackTimeoutMs || this.ackTimeoutMs,
+                callback: null,
+                cid: this._callIdGenerator(),
+                data: arg,
+                method: serviceMethod,
+                service: service
+            };
+        }
+        else {
+            methodRequest = {
+                ackTimeoutMs: ackTimeoutMs || this.ackTimeoutMs,
+                callback: null,
+                cid: this._callIdGenerator(),
+                data: arg,
+                method: (typeof methodOptions === 'object') ? methodOptions.method : methodOptions
+            };
+        }
+        const callbackMap = this._callbackMap;
+        let abort;
+        const baseRequest = (serviceRequest || methodRequest);
+        const promise = new Promise((resolve, reject) => {
+            if (baseRequest.ackTimeoutMs) {
+                baseRequest.timeoutId = setTimeout(() => {
+                    delete callbackMap[baseRequest.cid];
+                    baseRequest.callback = null;
+                    clearTimeout(baseRequest.timeoutId);
+                    delete baseRequest.timeoutId;
+                    reject(new TimeoutError(`Method '${[service, baseRequest.method].filter(Boolean).join('.')}' timed out.`));
+                }, baseRequest.ackTimeoutMs);
+            }
+            abort = () => {
+                delete callbackMap[baseRequest.cid];
+                if (baseRequest.timeoutId) {
+                    clearTimeout(baseRequest.timeoutId);
+                    delete baseRequest.timeoutId;
+                }
+                if (baseRequest.callback) {
+                    baseRequest.callback = null;
+                    reject(new AbortError(`Method '${[service, baseRequest.method].filter(Boolean).join('.')}' was aborted.`));
+                }
+            };
+            baseRequest.callback = (err, result) => {
+                delete callbackMap[baseRequest.cid];
+                baseRequest.callback = null;
+                if (baseRequest.timeoutId) {
+                    clearTimeout(baseRequest.timeoutId);
+                    delete baseRequest.timeoutId;
+                }
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(result);
+            };
+            baseRequest.sentCallback = () => {
+                delete baseRequest.sentCallback;
+                this._outboundSentMessageCount++;
+            };
+        });
+        this._outboundPreparedMessageCount++;
+        const request = Object.assign(baseRequest, { promise });
+        this.onInvoke(request);
+        return [promise, abort];
+    }
     onClose(code, reason) {
         const prevStatus = this.status;
         this.webSocket = null;
         this._isReady = false;
-        clearTimeout(this._pingTimeoutRef);
-        this._pingTimeoutRef = null;
+        if (this._pingTimeoutRef) {
+            clearTimeout(this._pingTimeoutRef);
+            this._pingTimeoutRef = null;
+        }
         this.abortAllPendingCallbacksDueToBadConnection(prevStatus);
         for (const plugin of this.plugins) {
             if (plugin.onClose) {
                 plugin.onClose({ socket: this.socket, transport: this });
             }
         }
-        if (!socketProtocolIgnoreStatuses[code]) {
+        if (!SocketProtocolIgnoreStatuses[code]) {
             let closeMessage;
             if (typeof reason === 'string') {
                 closeMessage = `Socket connection closed with status code ${code} and reason: ${reason}`;
@@ -131,9 +240,9 @@ export class SocketTransport {
             else {
                 closeMessage = `Socket connection closed with status code ${code}`;
             }
-            this.onError(new SocketProtocolError(socketProtocolErrorStatuses[code] || closeMessage, code));
+            this.onError(new SocketProtocolError(SocketProtocolErrorStatuses[code] || closeMessage, code));
         }
-        const strReason = reason?.toString() || socketProtocolErrorStatuses[code];
+        const strReason = reason?.toString() || SocketProtocolErrorStatuses[code];
         this._socket.emit('close', { code, reason: strReason });
     }
     onDisconnect(status, code, reason) {
@@ -145,7 +254,7 @@ export class SocketTransport {
         }
         for (const plugin of this.plugins) {
             if (plugin.onDisconnected) {
-                plugin.onDisconnected({ socket: this.socket, transport: this, status, code, reason });
+                plugin.onDisconnected({ code, reason, socket: this.socket, status, transport: this });
             }
         }
     }
@@ -172,19 +281,19 @@ export class SocketTransport {
         this._inboundReceivedMessageCount++;
         for (let i = 0; i < this.plugins.length; i++) {
             const plugin = this.plugins[i];
-            if (plugin.onMessageRaw) {
-                p = p.then(message => {
-                    return plugin.onMessageRaw({ socket: this.socket, transport: this, message, timestamp, promise });
+            if (plugin?.onMessageRaw) {
+                p = p.then((message) => {
+                    return plugin.onMessageRaw({ message, promise, socket: this.socket, timestamp, transport: this });
                 });
             }
         }
-        p.then(data => {
+        p.then((data) => {
             const packet = this.decode(data);
             this._socket.emit('message', { data, isBinary });
             return this.handleInboudMessage({ packet, timestamp });
         })
             .then(resolve)
-            .catch(err => {
+            .catch((err) => {
             reject(err);
             if (!(err instanceof PluginBlockedError)) {
                 this.onError(err);
@@ -204,14 +313,16 @@ export class SocketTransport {
     onPingPong() { }
     async onRequest(packet, timestamp, pluginError) {
         this._socket.emit('request', { request: packet });
-        const timeoutAt = typeof packet.ackTimeoutMs === 'number' ? new Date(timestamp.valueOf() + packet.ackTimeoutMs) : null;
+        const timeoutAt = typeof packet.ackTimeoutMs === 'number' ? new Date(timestamp.valueOf() + packet.ackTimeoutMs) : undefined;
         let wasHandled = false;
         let response;
         let error;
         if (pluginError) {
             wasHandled = true;
             error = pluginError;
-            response = { rid: packet.cid, timeoutAt, error: pluginError };
+            if (packet.cid) {
+                response = { error: pluginError, rid: packet.cid, timeoutAt };
+            }
         }
         else {
             const handler = this._handlers[packet.method];
@@ -220,20 +331,20 @@ export class SocketTransport {
                 try {
                     const data = await handler(new RequestHandlerArgs({
                         isRpc: !!packet.cid,
-                        method: packet.method.toString(),
-                        timeoutMs: packet.ackTimeoutMs,
+                        method: packet.method,
+                        options: packet.data,
                         socket: this._socket,
-                        transport: this,
-                        options: packet.data
+                        timeoutMs: packet.ackTimeoutMs,
+                        transport: this
                     }));
                     if (packet.cid) {
-                        response = { rid: packet.cid, timeoutAt, data };
+                        response = { data, rid: packet.cid, timeoutAt };
                     }
                 }
                 catch (err) {
-                    error = err;
+                    error = toError(err);
                     if (packet.cid) {
-                        response = { rid: packet.cid, timeoutAt, error };
+                        response = { error, rid: packet.cid, timeoutAt };
                     }
                 }
             }
@@ -267,7 +378,7 @@ export class SocketTransport {
             }
         }
         if (pluginError) {
-            this._socket.emit('response', { response: { rid: response.rid, error: pluginError } });
+            this._socket.emit('response', { response: { error: pluginError, rid: response.rid } });
         }
         else {
             this._socket.emit('response', { response });
@@ -285,10 +396,7 @@ export class SocketTransport {
     onTransmit(request) {
         this.sendRequest([request]);
     }
-    onUnhandledRequest(packet) {
-        if (this._onUnhandledRequest) {
-            return this._onUnhandledRequest(this, packet);
-        }
+    onUnhandledRequest(_) {
         return false;
     }
     resetPingTimeout(timeoutMs, code) {
@@ -302,24 +410,25 @@ export class SocketTransport {
             // Delay should be equal to the interval at which your server
             // sends out pings plus a conservative assumption of the latency.
             this._pingTimeoutRef = setTimeout(() => {
-                this.webSocket.close(code);
+                if (this._webSocket) {
+                    this._webSocket.close(code);
+                }
             }, timeoutMs);
         }
     }
     send(data) {
         return new Promise((resolve, reject) => {
-            try {
-                this._webSocket.send(data, (err) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve();
-                });
-            }
-            catch (err) {
-                throw err;
+            if (!this._webSocket) {
+                reject(new SocketClosedError('Web socket is closed.'));
+                return;
             }
+            this._webSocket.send(data, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
         });
     }
     sendRequest(index, requests) {
@@ -327,6 +436,9 @@ export class SocketTransport {
             requests = index;
             index = 0;
         }
+        if (!requests) {
+            return; // Shouldn't happen
+        }
         // Filter out any requests that have already timed out.
         if (requests.some(request => isRequestDone(request))) {
             requests = requests.filter(req => isRequestDone(req));
@@ -336,19 +448,20 @@ export class SocketTransport {
         }
         for (; index < this.plugins.length; index++) {
             const plugin = this.plugins[index];
-            if ('sendRequest' in plugin) {
+            if (plugin?.sendRequest) {
                 index++;
                 try {
                     plugin.sendRequest({
-                        socket: this.socket,
-                        transport: this,
+                        cont: this.sendRequest.bind(this, index),
                         requests,
-                        cont: this.sendRequest.bind(this, index)
+                        socket: this.socket,
+                        transport: this
                     });
                 }
                 catch (err) {
+                    const error = toError(err);
                     for (const req of requests) {
-                        abortRequest(req, err);
+                        abortRequest(req, error);
                     }
                 }
                 return;
@@ -363,13 +476,13 @@ export class SocketTransport {
             }
             return;
         }
-        const encode = requests.map(req => {
-            if ('callback' in req) {
+        const encode = requests.map((req) => {
+            if ('callback' in req && req.callback) {
                 const { callback, promise, timeoutId, ...rest } = req;
                 this._callbackMap[req.cid] = {
+                    callback: req.callback,
                     method: ['service' in req ? req.service : '', req.method].filter(Boolean).join('.'),
-                    timeoutId: req.timeoutId,
-                    callback: req.callback
+                    timeoutId: req.timeoutId
                 };
                 return rest;
             }
@@ -377,7 +490,7 @@ export class SocketTransport {
             return rest;
         });
         let sendErr;
-        this.send(this.codecEngine.encode(encode.length === 1 ? encode[0] : encode)).catch(err => {
+        this.send(this.codecEngine.encode(encode.length === 1 ? encode[0] : encode)).catch((err) => {
             sendErr = err;
         }).then(() => {
             const errCode = sendErr?.code;
@@ -388,11 +501,11 @@ export class SocketTransport {
                 if (req.sentCallback) {
                     req.sentCallback(sendErr);
                 }
-                if (sendErr && 'callback' in req) {
+                if (sendErr && 'callback' in req && req.callback) {
                     req.callback(sendErr);
                 }
             }
-        }).catch(err => {
+        }).catch((err) => {
             this.onError(err);
         });
     }
@@ -401,31 +514,34 @@ export class SocketTransport {
             responses = index;
             index = 0;
         }
+        if (!responses) {
+            return; // shouldn't happen
+        }
         // Remove any response that has timed out
         if (!(responses = responses.filter(item => !item.timeoutAt || item.timeoutAt > new Date())).length) {
             return;
         }
         for (; index < this.plugins.length; index++) {
             const plugin = this.plugins[index];
-            if ('sendResponse' in plugin) {
+            if (plugin && 'sendResponse' in plugin && plugin.sendResponse) {
                 index++;
                 try {
                     plugin.sendResponse({
-                        socket: this.socket,
-                        transport: this,
+                        cont: this.sendResponse.bind(this, index),
                         responses,
-                        cont: this.sendResponse.bind(this, index)
+                        socket: this.socket,
+                        transport: this
                     });
                 }
                 catch (err) {
-                    this.sendResponse(index, responses.map(item => ({ rid: item.rid, timeoutAt: item.timeoutAt, error: err })));
+                    this.sendResponse(index, responses.map(item => ({ error: err, rid: item.rid, timeoutAt: item.timeoutAt })));
                 }
                 return;
             }
         }
         // If the socket is closed we need to call them back with an error.
         if (this.status === 'closed') {
-            for (const response of responses) {
+            for (const _ of responses) {
                 this.onError(new Error(`WebSocket is not open: readyState 3 (CLOSED)`));
             }
             return;
@@ -436,25 +552,23 @@ export class SocketTransport {
             }
             delete response.timeoutAt;
         }
-        //timeoutId?: NodeJS.Timeout;
-        //callback: (err: Error, result?: U) => void | null
-        this.send(this.codecEngine.encode(responses.length === 1 ? responses[0] : responses)).catch(err => {
+        // timeoutId?: NodeJS.Timeout;
+        // callback: (err: Error, result?: U) => void | null
+        this.send(this.codecEngine.encode(responses.length === 1 ? responses[0] : responses)).catch((err) => {
             this.onError(err);
         });
     }
     async setAuthorization(signedAuthToken, authToken) {
-        if (typeof signedAuthToken !== 'string') {
-            throw new InvalidArgumentsError('SignedAuthToken must be type string.');
-        }
         if (signedAuthToken !== this._signedAuthToken) {
-            if (!authToken) {
+            let newAuthToken = authToken;
+            if (!newAuthToken) {
                 const extractedAuthToken = extractAuthTokenData(signedAuthToken);
                 if (typeof extractedAuthToken === 'string') {
                     throw new InvalidArgumentsError('Invalid authToken.');
                 }
-                authToken = extractedAuthToken;
+                newAuthToken = extractedAuthToken;
             }
-            this._authToken = authToken;
+            this._authToken = newAuthToken;
             this._signedAuthToken = signedAuthToken;
             return true;
         }
@@ -470,7 +584,7 @@ export class SocketTransport {
                 plugin.onReady({ socket: this.socket, transport: this });
             }
         }
-        this._socket.emit('connect', { id: this.id, pingTimeoutMs, isAuthenticated: !!this.signedAuthToken, authError });
+        this._socket.emit('connect', { authError, id: this.id, isAuthenticated: !!this.signedAuthToken, pingTimeoutMs });
     }
     get signedAuthToken() {
         return this._signedAuthToken;
@@ -489,48 +603,35 @@ export class SocketTransport {
             return 'ready';
         }
         switch (this._webSocket.readyState) {
+            case ws.CLOSING:
+                return 'closing';
             case ws.CONNECTING:
             case ws.OPEN:
                 return 'connecting';
-            case ws.CLOSING:
-                return 'closing';
             default:
                 return 'closed';
         }
     }
-    triggerAuthenticationEvents(wasSigned, wasAuthenticated) {
-        this._socket.emit('authStateChange', { wasAuthenticated, isAuthenticated: true, authToken: this._authToken, signedAuthToken: this._signedAuthToken });
-        this._socket.emit('authenticate', { wasSigned, signedAuthToken: this._signedAuthToken, authToken: this._authToken });
-        for (const plugin of this.plugins) {
-            if (plugin.onAuthenticated) {
-                plugin.onAuthenticated({ socket: this.socket, transport: this });
-            }
-        }
-    }
     transmit(serviceAndMethod, arg) {
-        let service;
-        let serviceMethod;
-        let method;
+        let serviceRequest;
+        let methodRequest;
         if (Array.isArray(serviceAndMethod)) {
-            service = serviceAndMethod[0];
-            serviceMethod = serviceAndMethod[1];
+            serviceRequest = {
+                data: arg,
+                method: serviceAndMethod[1],
+                service: serviceAndMethod[0]
+            };
         }
         else {
-            method = serviceAndMethod;
-        }
-        const request = service ? {
-            service,
-            method: serviceMethod,
-            promise: null,
-            data: arg
-        } : {
-            data: arg,
-            method,
-            promise: null
-        };
-        const promise = request.promise = new Promise((resolve, reject) => {
-            request.sentCallback = (err) => {
-                delete request.sentCallback;
+            methodRequest = {
+                data: arg,
+                method: serviceAndMethod
+            };
+        }
+        const baseRequest = (serviceRequest || methodRequest);
+        const promise = new Promise((resolve, reject) => {
+            baseRequest.sentCallback = (err) => {
+                delete baseRequest.sentCallback;
                 this._outboundSentMessageCount++;
                 if (err) {
                     reject(err);
@@ -540,94 +641,24 @@ export class SocketTransport {
             };
         });
         this._outboundPreparedMessageCount++;
+        const request = Object.assign(baseRequest, { promise });
         this.onTransmit(request);
-        return promise;
+        return request.promise;
     }
-    invoke(methodOptions, arg) {
-        let service;
-        let serviceMethod;
-        let method;
-        let ackTimeoutMs;
-        if (typeof methodOptions === 'object') {
-            if (Array.isArray(methodOptions)) {
-                service = methodOptions[0];
-                serviceMethod = methodOptions[1];
-                ackTimeoutMs = methodOptions[2];
-            }
-            else {
-                if ('service' in methodOptions) {
-                    service = methodOptions.service;
-                    serviceMethod = methodOptions.method;
-                }
-                else {
-                    method = methodOptions.method;
-                }
-                ackTimeoutMs = methodOptions.ackTimeoutMs;
-            }
+    triggerAuthenticationEvents(wasSigned, wasAuthenticated) {
+        if (!this._signedAuthToken) {
+            throw new AuthError('Signed auth token should be set to trigger authentication events');
         }
-        else {
-            method = methodOptions;
-        }
-        let callbackMap = this._callbackMap;
-        const request = Object.assign({
-            cid: this._callIdGenerator(),
-            ackTimeoutMs: ackTimeoutMs ?? this.ackTimeoutMs,
-            callback: null,
-            promise: null
-        }, service ? {
-            service,
-            method: serviceMethod,
-            data: arg
-        } : {
-            method: method,
-            data: arg
-        });
-        let abort;
-        const promise = request.promise = new Promise((resolve, reject) => {
-            if (request.ackTimeoutMs) {
-                request.timeoutId = setTimeout(() => {
-                    delete callbackMap[request.cid];
-                    request.callback = null;
-                    clearTimeout(request.timeoutId);
-                    delete request.timeoutId;
-                    reject(new TimeoutError(`Method \'${[service, request.method].filter(Boolean).join('.')}\' timed out.`));
-                }, request.ackTimeoutMs);
+        this._socket.emit('authStateChange', { authToken: this._authToken, isAuthenticated: true, signedAuthToken: this._signedAuthToken, wasAuthenticated });
+        this._socket.emit('authenticate', { authToken: this._authToken, signedAuthToken: this._signedAuthToken, wasSigned });
+        for (const plugin of this.plugins) {
+            if (plugin.onAuthenticated) {
+                plugin.onAuthenticated({ socket: this.socket, transport: this });
             }
-            abort = () => {
-                delete callbackMap[request.cid];
-                if (request.timeoutId) {
-                    clearTimeout(request.timeoutId);
-                    delete request.timeoutId;
-                }
-                if (request.callback) {
-                    request.callback = null;
-                    reject(new AbortError(`Method \'${[service, request.method].filter(Boolean).join('.')}\' was aborted.`));
-                }
-            };
-            request.callback = (err, result) => {
-                delete callbackMap[request.cid];
-                request.callback = null;
-                if (request.timeoutId) {
-                    clearTimeout(request.timeoutId);
-                    delete request.timeoutId;
-                }
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                resolve(result);
-            };
-            request.sentCallback = () => {
-                delete request.sentCallback;
-                this._outboundSentMessageCount++;
-            };
-        });
-        this._outboundPreparedMessageCount++;
-        this.onInvoke(request);
-        return [promise, abort];
+        }
     }
     get url() {
-        return this._webSocket.url;
+        return this._webSocket?.url || '';
     }
     get webSocket() {
         return this._webSocket;
@@ -638,17 +669,13 @@ export class SocketTransport {
             this._webSocket.onerror = null;
             this._webSocket.onmessage = null;
             this._webSocket.onopen = null;
-            delete this.onSocketClose;
-            delete this.onSocketError;
-            delete this.onSocketMessage;
-            delete this.onOpen;
         }
         this._webSocket = value;
-        if (value) {
-            this._webSocket.onclose = this.onSocketClose = this.onSocketClose.bind(this);
-            this._webSocket.onopen = this.onOpen = this.onOpen.bind(this);
-            this._webSocket.onerror = this.onSocketError = this.onSocketError.bind(this);
-            this._webSocket.onmessage = this.onSocketMessage = this.onSocketMessage.bind(this);
+        if (this._webSocket) {
+            this._webSocket.onclose = this.onSocketClose.bind(this);
+            this._webSocket.onopen = this.onOpen.bind(this);
+            this._webSocket.onerror = this.onSocketError.bind(this);
+            this._webSocket.onmessage = this.onSocketMessage.bind(this);
         }
     }
 }