@socket-mesh/core 1.0.0

package/dist/socket-transport.js

@@ -0,0 +1,671 @@
+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 {
+    constructor(options) {
+        let cid = 1;
+        this.ackTimeoutMs = options?.ackTimeoutMs ?? 10000;
+        this._callIdGenerator = options?.callIdGenerator || (() => {
+            return cid++;
+        });
+        this._callbackMap = {};
+        this.codecEngine = options?.codecEngine || defaultCodec;
+        this._handlers = options?.handlers || {};
+        this.id = null;
+        this._inboundProcessedMessageCount = 0;
+        this._inboundReceivedMessageCount = 0;
+        this._outboundPreparedMessageCount = 0;
+        this._outboundSentMessageCount = 0;
+        this._pingTimeoutRef = null;
+        this.plugins = options?.plugins || [];
+        this.streamCleanupMode = options?.streamCleanupMode || 'kill';
+    }
+    abortAllPendingCallbacksDueToBadConnection(status) {
+        for (const cid in this._callbackMap) {
+            const map = this._callbackMap[cid];
+            const msg = `Event ${map.method} was aborted due to a bad connection`;
+            map.callback(new BadConnectionError(msg, status === 'ready' ? 'disconnect' : 'connectAbort'));
+        }
+    }
+    get authToken() {
+        return this._authToken;
+    }
+    async changeToUnauthenticatedState() {
+        if (this._signedAuthToken) {
+            const authToken = this._authToken;
+            const signedAuthToken = this._signedAuthToken;
+            this._authToken = null;
+            this._signedAuthToken = null;
+            this._socket.emit('authStateChange', { wasAuthenticated: true, isAuthenticated: false });
+            // In order for the events to trigger we need to wait for the next tick.
+            await wait(0);
+            this._socket.emit('deauthenticate', { signedAuthToken, authToken });
+            for (const plugin of this.plugins) {
+                if (plugin.onDeauthenticate) {
+                    plugin.onDeauthenticate({ socket: this.socket, transport: this });
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    decode(data) {
+        try {
+            return this.codecEngine.decode(data);
+        }
+        catch (err) {
+            if (err.name === 'Error') {
+                err.name = 'InvalidMessageError';
+            }
+            this.onError(err);
+            return null;
+        }
+    }
+    disconnect(code = 1000, reason) {
+        if (this.webSocket) {
+            this.webSocket.close(code, reason);
+            this.onClose(code, reason);
+        }
+    }
+    getBackpressure() {
+        return Math.max(this.getInboundBackpressure(), this.getOutboundBackpressure());
+    }
+    getInboundBackpressure() {
+        return this._inboundReceivedMessageCount - this._inboundProcessedMessageCount;
+    }
+    getOutboundBackpressure() {
+        return this._outboundPreparedMessageCount - this._outboundSentMessageCount;
+    }
+    async handleInboudMessage({ data, timestamp }) {
+        let packet = this.decode(data);
+        if (packet === null) {
+            return;
+        }
+        packet = toArray(packet);
+        for (let curPacket of packet) {
+            let pluginError;
+            try {
+                for (const plugin of this.plugins) {
+                    if (plugin.onMessage) {
+                        curPacket = await plugin.onMessage({ socket: this.socket, transport: this, packet: curPacket, timestamp: timestamp });
+                    }
+                }
+            }
+            catch (err) {
+                pluginError = err;
+            }
+            // Check to see if it is a request or response packet. 
+            if (isResponsePacket(curPacket)) {
+                this.onResponse(curPacket, pluginError);
+            }
+            else if (isRequestPacket(curPacket)) {
+                await this.onRequest(curPacket, timestamp, pluginError);
+            }
+            else {
+                // TODO: Handle non packets here (binary data)
+            }
+        }
+    }
+    onClose(code, reason) {
+        const prevStatus = this.status;
+        this.webSocket = null;
+        this._isReady = false;
+        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]) {
+            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}`;
+            }
+            this.onError(new SocketProtocolError(socketProtocolErrorStatuses[code] || closeMessage, code));
+        }
+        const strReason = reason?.toString() || socketProtocolErrorStatuses[code];
+        this._socket.emit('close', { code, reason: strReason });
+    }
+    onDisconnect(status, code, reason) {
+        if (status === 'ready') {
+            this._socket.emit('disconnect', { code, reason });
+        }
+        else {
+            this._socket.emit('connectAbort', { code, reason });
+        }
+        for (const plugin of this.plugins) {
+            if (plugin.onDisconnected) {
+                plugin.onDisconnected({ socket: this.socket, transport: this, status, code, reason });
+            }
+        }
+    }
+    onError(error) {
+        this._socket.emit('error', { error });
+    }
+    onInvoke(request) {
+        this.sendRequest([request]);
+    }
+    onMessage(data, isBinary) {
+        const timestamp = new Date();
+        let p = Promise.resolve(isBinary ? data : data.toString());
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        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 });
+                });
+            }
+        }
+        p.then(data => {
+            this._socket.emit('message', { data, isBinary });
+            return this.handleInboudMessage({ data, timestamp });
+        })
+            .then(resolve)
+            .catch(err => {
+            reject(err);
+            if (!(err instanceof PluginBlockedError)) {
+                this.onError(err);
+            }
+        }).finally(() => {
+            this._inboundProcessedMessageCount++;
+        });
+    }
+    onOpen() {
+        // Placeholder for inherited classes
+        for (const plugin of this.plugins) {
+            if (plugin.onOpen) {
+                plugin.onOpen({ socket: this.socket, transport: this });
+            }
+        }
+    }
+    onPing(data) {
+        this._socket.emit('ping', { data });
+    }
+    onPong(data) {
+        this._socket.emit('pong', { data });
+    }
+    async onRequest(packet, timestamp, pluginError) {
+        this._socket.emit('request', { request: packet });
+        const timeoutAt = typeof packet.ackTimeoutMs === 'number' ? new Date(timestamp.valueOf() + packet.ackTimeoutMs) : null;
+        let wasHandled = false;
+        let response;
+        let error;
+        if (pluginError) {
+            wasHandled = true;
+            error = pluginError;
+            response = { rid: packet.cid, timeoutAt, error: pluginError };
+        }
+        else {
+            const handler = this._handlers[packet.method];
+            if (handler) {
+                wasHandled = true;
+                try {
+                    const data = await handler(new RequestHandlerArgs({
+                        isRpc: !!packet.cid,
+                        method: packet.method.toString(),
+                        timeoutMs: packet.ackTimeoutMs,
+                        socket: this._socket,
+                        transport: this,
+                        options: packet.data
+                    }));
+                    if (packet.cid) {
+                        response = { rid: packet.cid, timeoutAt, data };
+                    }
+                }
+                catch (err) {
+                    error = err;
+                    if (packet.cid) {
+                        response = { rid: packet.cid, timeoutAt, error };
+                    }
+                }
+            }
+        }
+        if (response) {
+            this.sendResponse([response]);
+        }
+        if (error) {
+            this.onError(error);
+        }
+        if (!wasHandled) {
+            wasHandled = this.onUnhandledRequest(packet);
+        }
+        return wasHandled;
+    }
+    onResponse(response, pluginError) {
+        const map = this._callbackMap[response.rid];
+        if (map) {
+            if (map.timeoutId) {
+                clearTimeout(map.timeoutId);
+                delete map.timeoutId;
+            }
+            if (pluginError) {
+                map.callback(pluginError);
+            }
+            else if ('error' in response) {
+                map.callback(hydrateError(response.error));
+            }
+            else {
+                map.callback(null, 'data' in response ? response.data : undefined);
+            }
+        }
+        if (pluginError) {
+            this._socket.emit('response', { response: { rid: response.rid, error: pluginError } });
+        }
+        else {
+            this._socket.emit('response', { response });
+        }
+    }
+    onTransmit(request) {
+        this.sendRequest([request]);
+    }
+    onUnexpectedResponse(request, response) {
+        this._socket.emit('unexpectedResponse', { request, response });
+    }
+    onUnhandledRequest(packet) {
+        if (this._onUnhandledRequest) {
+            return this._onUnhandledRequest(this, packet);
+        }
+        return false;
+    }
+    onUpgrade(request) {
+        this._socket.emit('upgrade', { request });
+    }
+    ping() {
+        return new Promise((resolve, reject) => {
+            this.webSocket.ping(undefined, undefined, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    resetPingTimeout(timeoutMs, code) {
+        if (this._pingTimeoutRef) {
+            clearTimeout(this._pingTimeoutRef);
+            this._pingTimeoutRef = null;
+        }
+        if (timeoutMs !== false) {
+            // Use `WebSocket#terminate()`, which immediately destroys the connection,
+            // instead of `WebSocket#close()`, which waits for the close timer.
+            // 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);
+            }, timeoutMs);
+        }
+    }
+    send(data) {
+        return new Promise((resolve, reject) => {
+            try {
+                this._webSocket.send(data, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    sendRequest(index, requests) {
+        if (typeof index === 'object') {
+            requests = index;
+            index = 0;
+        }
+        // Filter out any requests that have already timed out.
+        if (requests.some(request => isRequestDone(request))) {
+            requests = requests.filter(req => isRequestDone(req));
+            if (!requests.length) {
+                return;
+            }
+        }
+        for (; index < this.plugins.length; index++) {
+            const plugin = this.plugins[index];
+            if ('sendRequest' in plugin) {
+                index++;
+                try {
+                    plugin.sendRequest({
+                        socket: this.socket,
+                        transport: this,
+                        requests,
+                        cont: this.sendRequest.bind(this, index)
+                    });
+                }
+                catch (err) {
+                    for (const req of requests) {
+                        abortRequest(req, err);
+                    }
+                }
+                return;
+            }
+        }
+        // If the socket is closed we need to call them back with an error.
+        if (this.status === 'closed') {
+            for (const req of requests) {
+                const err = new BadConnectionError(`Socket ${'callback' in req ? 'invoke' : 'transmit'} ${String(req.method)} event was aborted due to a bad connection`, 'connectAbort');
+                this.onError(err);
+                abortRequest(req, err);
+            }
+            return;
+        }
+        const encode = requests.map(req => {
+            if ('callback' in req) {
+                const { callback, promise, timeoutId, ...rest } = req;
+                this._callbackMap[req.cid] = {
+                    method: ['service' in req ? req.service : '', req.method].filter(Boolean).join('.'),
+                    timeoutId: req.timeoutId,
+                    callback: req.callback
+                };
+                return rest;
+            }
+            const { promise, ...rest } = req;
+            return rest;
+        });
+        this._webSocket.send(this.codecEngine.encode(encode.length === 1 ? encode[0] : encode), (err) => {
+            for (const req of requests) {
+                if (err?.code === 'ECONNRESET') {
+                    err = new BadConnectionError(`Socket ${'callback' in req ? 'invoke' : 'transmit'} ${String(req.method)} event was aborted due to a bad connection`, 'connectAbort');
+                }
+                if (req.sentCallback) {
+                    req.sentCallback(err);
+                }
+                if (err && 'callback' in req) {
+                    req.callback(err);
+                }
+            }
+        });
+    }
+    sendResponse(index, responses) {
+        if (typeof index === 'object') {
+            responses = index;
+            index = 0;
+        }
+        // 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) {
+                index++;
+                try {
+                    plugin.sendResponse({
+                        socket: this.socket,
+                        transport: this,
+                        responses,
+                        cont: this.sendResponse.bind(this, index)
+                    });
+                }
+                catch (err) {
+                    this.sendResponse(index, responses.map(item => ({ rid: item.rid, timeoutAt: item.timeoutAt, error: err })));
+                }
+                return;
+            }
+        }
+        // If the socket is closed we need to call them back with an error.
+        if (this.status === 'closed') {
+            for (const response of responses) {
+                this.onError(new Error(`WebSocket is not open: readyState 3 (CLOSED)`));
+            }
+            return;
+        }
+        for (const response of responses) {
+            if ('error' in response) {
+                response.error = dehydrateError(response.error);
+            }
+            delete response.timeoutAt;
+        }
+        //timeoutId?: NodeJS.Timeout;
+        //callback: (err: Error, result?: U) => void | null
+        this._webSocket.send(this.codecEngine.encode(responses.length === 1 ? responses[0] : responses), (err) => {
+            if (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) {
+                const extractedAuthToken = extractAuthTokenData(signedAuthToken);
+                if (typeof extractedAuthToken === 'string') {
+                    throw new InvalidArgumentsError('Invalid authToken.');
+                }
+                authToken = extractedAuthToken;
+            }
+            this._authToken = authToken;
+            this._signedAuthToken = signedAuthToken;
+            return true;
+        }
+        return false;
+    }
+    setReadyStatus(pingTimeoutMs, authError) {
+        if (this._webSocket?.readyState !== ws.OPEN) {
+            throw new InvalidActionError('Cannot set status to OPEN before socket is connected.');
+        }
+        this._isReady = true;
+        for (const plugin of this.plugins) {
+            if (plugin.onReady) {
+                plugin.onReady({ socket: this.socket, transport: this });
+            }
+        }
+        this._socket.emit('connect', { id: this.id, pingTimeoutMs, isAuthenticated: !!this.signedAuthToken, authError });
+    }
+    get signedAuthToken() {
+        return this._signedAuthToken;
+    }
+    get socket() {
+        return this._socket;
+    }
+    set socket(value) {
+        this._socket = value;
+    }
+    get status() {
+        if (!this._webSocket) {
+            return 'closed';
+        }
+        if (this._isReady) {
+            return 'ready';
+        }
+        switch (this._webSocket.readyState) {
+            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;
+        if (Array.isArray(serviceAndMethod)) {
+            service = serviceAndMethod[0];
+            serviceMethod = serviceAndMethod[1];
+        }
+        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;
+                this._outboundSentMessageCount++;
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            };
+        });
+        this._outboundPreparedMessageCount++;
+        this.onTransmit(request);
+        return 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;
+            }
+        }
+        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);
+            }
+            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;
+    }
+    get webSocket() {
+        return this._webSocket;
+    }
+    set webSocket(value) {
+        if (this._webSocket) {
+            this._webSocket.off('open', this.onOpen);
+            this._webSocket.off('close', this.onClose);
+            this._webSocket.off('error', this.onError);
+            this._webSocket.off('upgrade', this.onUpgrade);
+            this._webSocket.off('message', this.onMessage);
+            this._webSocket.off('ping', this.onPing);
+            this._webSocket.off('pong', this.onPong);
+            this._webSocket.off('unexpectedResponse', this.onUnexpectedResponse);
+            delete this.onOpen;
+            delete this.onClose;
+            delete this.onError;
+            delete this.onUpgrade;
+            delete this.onMessage;
+            delete this.onPing;
+            delete this.onPong;
+            delete this.onUnexpectedResponse;
+        }
+        this._webSocket = value;
+        if (value) {
+            this._webSocket.on('open', this.onOpen = this.onOpen.bind(this));
+            this._webSocket.on('close', this.onClose = this.onClose.bind(this));
+            this._webSocket.on('error', this.onError = this.onError.bind(this));
+            this._webSocket.on('upgrade', this.onUpgrade = this.onUpgrade.bind(this));
+            this._webSocket.on('message', this.onMessage = this.onMessage.bind(this));
+            this._webSocket.on('ping', this.onPing = this.onPing.bind(this));
+            this._webSocket.on('pong', this.onPong = this.onPong.bind(this));
+            this._webSocket.on('unexpectedResponse', this.onUnexpectedResponse = this.onUnexpectedResponse.bind(this));
+        }
+    }
+}