@xelis/sdk 0.5.2 → 0.5.4

package/lib/websocket.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MessageEvent } from 'ws';
 import WebSocket from 'isomorphic-ws';
 import { RPCResponse } from './types';
@@ -6,14 +5,14 @@ export declare class WS {
     endpoint: string;
     socket?: WebSocket;
     timeout: number;
-    connected: boolean;
     unsubscribeSuspense: number;
+    reconnectOnConnectionLoss: boolean;
+    maxConnectionTries: number;
+    connectionTries: number;
     private events;
     constructor();
     connect(endpoint: string): Promise<unknown>;
-    close(code?: number | undefined, data?: string | Buffer | undefined): void;
-    onClose(cb: (event: WebSocket.CloseEvent) => void): void;
-    onError(cb: (err: WebSocket.ErrorEvent) => void): void;
+    tryReconnect(): void;
     private clearEvent;
     closeAllListens(event: string): Promise<void>;
     listenEvent<T>(event: string, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;

package/lib/websocket.js

@@ -10,48 +10,52 @@ function createRequestMethod(method, params) {
 }
 export class WS {
     constructor() {
+        this.connectionTries = 0;
         this.endpoint = "";
         this.timeout = 3000;
-        this.connected = false;
         this.events = {};
         this.unsubscribeSuspense = 1000;
+        this.maxConnectionTries = 3;
+        this.reconnectOnConnectionLoss = true;
     }
     connect(endpoint) {
-        if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
+        // force disconnect if already connected
+        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
             this.socket.close();
         }
+        this.events = {};
+        this.connectionTries = 0;
         return new Promise((resolve, reject) => {
             this.socket = new WebSocket(endpoint);
             this.endpoint = endpoint;
             this.socket.addEventListener(`open`, (event) => {
-                this.connected = true;
                 resolve(event);
             });
-            this.socket.addEventListener(`close`, () => {
-                this.connected = false;
-                reject();
+            this.socket.addEventListener(`close`, (event) => {
+                if (this.reconnectOnConnectionLoss && !event.wasClean) {
+                    this.tryReconnect();
+                    reject(new Error(`Unhandled close. Reconnecting...`));
+                }
+                else {
+                    reject(event);
+                }
             });
             this.socket.addEventListener(`error`, (err) => {
-                this.connected = false;
                 reject(err);
             });
         });
     }
-    close(code, data) {
-        this.socket && this.socket.close(code, data);
-    }
-    onClose(cb) {
-        if (!this.socket)
+    tryReconnect() {
+        this.connectionTries++;
+        if (this.connectionTries > this.maxConnectionTries) {
             return;
-        this.socket.addEventListener(`close`, (event) => {
-            cb(event);
+        }
+        this.socket = new WebSocket(this.endpoint);
+        this.socket.addEventListener(`open`, () => {
+            this.connectionTries = 0;
         });
-    }
-    onError(cb) {
-        if (!this.socket)
-            return;
-        this.socket.addEventListener(`error`, (err) => {
-            cb(err);
+        this.socket.addEventListener(`close`, (event) => {
+            this.tryReconnect();
         });
     }
     clearEvent(event) {
@@ -101,7 +105,7 @@ export class WS {
             this.events[event].listeners.push(onMessage);
         }
         else {
-            // important if multiple listenEvent are called without await atleast we store listener before getting id
+            // important if multiple listenEvent are called without await at least we store listener before getting id
             this.events[event] = { listeners: [onMessage] };
             const [err, res] = await to(this.call(`subscribe`, { notify: event }));
             if (err) {
@@ -121,12 +125,19 @@ export class WS {
                         break;
                     }
                 }
+                // no more listener so we unsubscribe from daemon websocket if socket still open
                 if (listeners.length === 0) {
-                    this.events[event].unsubscribeTimeoutId = setTimeout(async () => {
-                        // no more listener so we unsubscribe from daemon websocket
-                        this.call(`unsubscribe`, { notify: event });
+                    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                        // we use a grace period to unsubscribe (mostly because of react useEffect and avoid unecessary subscribe)
+                        this.events[event].unsubscribeTimeoutId = setTimeout(async () => {
+                            this.call(`unsubscribe`, { notify: event });
+                            Reflect.deleteProperty(this.events, event);
+                        }, this.unsubscribeSuspense);
+                    }
+                    else {
+                        // socket is closed so we don't send unsubscribe and no grace period delete right away
                         Reflect.deleteProperty(this.events, event);
-                    }, this.unsubscribeSuspense);
+                    }
                 }
             }
             this.socket && this.socket.removeEventListener(`message`, onMessage);
@@ -157,7 +168,9 @@ export class WS {
                 this.socket && this.socket.removeEventListener(`message`, onMessage);
                 reject(new Error(`timeout`));
             }, this.timeout);
-            this.socket && this.socket.send(data);
+            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                this.socket.send(data);
+            }
         });
     }
     dataCall(method, params) {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.2",
+  "version": "0.5.4",
   "name": "@xelis/sdk",
   "description": "Xelis software development kit for JS",
   "repository": {

package/react/daemon.d.ts

@@ -2,11 +2,11 @@ import React, { PropsWithChildren } from 'react';
 import { MessageEvent } from 'ws';
 import DaemonWS from '../daemon/websocket';
 import { RPCEvent } from '../daemon/types';
+export declare const INITIATING = -1;
 interface NodeSocket {
     daemon: DaemonWS;
-    loading: boolean;
-    err: any;
-    connected: boolean;
+    err?: Error;
+    readyState: number;
 }
 interface NodeSocketProviderProps {
     endpoint: string;
@@ -14,9 +14,9 @@ interface NodeSocketProviderProps {
 export declare const NodeSocketProvider: (props: PropsWithChildren<NodeSocketProviderProps>) => React.JSX.Element;
 interface NodeSocketSubscribeProps<T> {
     event: RPCEvent;
-    onConnected: () => void;
+    onLoad: () => void;
     onData: (msgEvent: MessageEvent, data?: T, err?: Error | undefined) => void;
 }
-export declare const useNodeSocketSubscribe: ({ event, onConnected, onData }: NodeSocketSubscribeProps<any>, dependencies: React.DependencyList) => void;
+export declare const useNodeSocketSubscribe: ({ event, onLoad, onData }: NodeSocketSubscribeProps<any>, dependencies: React.DependencyList) => void;
 export declare const useNodeSocket: () => NodeSocket;
 export default useNodeSocket;

package/react/daemon.js

@@ -2,49 +2,69 @@ import React, { createContext, useContext, useEffect, useState } from 'react';
 import to from 'await-to-js';
 import DaemonWS from '../daemon/websocket';
 const daemon = new DaemonWS();
+export const INITIATING = -1;
 const Context = createContext({
-    connected: false,
-    err: null,
-    loading: false,
+    err: undefined,
     daemon,
+    readyState: INITIATING
 });
 export const NodeSocketProvider = (props) => {
     const { children, endpoint } = props;
-    const [loading, setLoading] = useState(true);
-    const [connected, setConnected] = useState(false);
+    const [readyState, setReadyState] = useState(INITIATING);
     const [err, setErr] = useState();
     useEffect(() => {
-        const load = async () => {
-            setLoading(true);
-            const [err, res] = await to(daemon.connect(endpoint));
+        const connect = async () => {
+            setErr(undefined);
+            const [err, _] = await to(daemon.connect(endpoint));
             if (err)
                 setErr(err);
-            else
-                setConnected(true);
-            setLoading(false);
-            daemon.onError((err) => {
-                setErr(err);
-                setConnected(false);
-            });
-            daemon.onClose(() => {
-                setConnected(false);
-            });
         };
-        load();
+        connect();
     }, [endpoint]);
-    return React.createElement(Context.Provider, { value: { daemon, loading, err, connected } }, children);
+    useEffect(() => {
+        if (!daemon.socket)
+            return;
+        setReadyState(daemon.socket.readyState);
+        const onOpen = () => {
+            if (!daemon.socket)
+                return;
+            setReadyState(daemon.socket.readyState);
+            setErr(undefined);
+        };
+        const onClose = (event) => {
+            if (!daemon.socket)
+                return;
+            setReadyState(daemon.socket.readyState);
+            setErr(new Error(event.reason));
+        };
+        const onError = (err) => {
+            if (!daemon.socket)
+                return;
+            setReadyState(daemon.socket.readyState);
+            setErr(new Error(err.message));
+        };
+        daemon.socket.addEventListener(`open`, onOpen);
+        daemon.socket.addEventListener(`close`, onClose);
+        daemon.socket.addEventListener(`error`, onError);
+        return () => {
+            if (!daemon.socket)
+                return;
+            daemon.socket.removeEventListener(`open`, onOpen);
+            daemon.socket.removeEventListener(`close`, onClose);
+            daemon.socket.removeEventListener(`error`, onError);
+        };
+    }, [daemon.socket]);
+    return React.createElement(Context.Provider, { value: { daemon, err, readyState } }, children);
 };
-export const useNodeSocketSubscribe = ({ event, onConnected, onData }, dependencies) => {
+export const useNodeSocketSubscribe = ({ event, onLoad, onData }, dependencies) => {
     const nodeSocket = useNodeSocket();
     useEffect(() => {
-        if (!nodeSocket.connected)
+        if (nodeSocket.readyState !== WebSocket.OPEN)
             return;
-        if (typeof onConnected === `function`)
-            onConnected();
+        if (typeof onLoad === `function`)
+            onLoad();
         let closeEvent;
         const listen = async () => {
-            if (!nodeSocket.daemon)
-                return;
             closeEvent = await nodeSocket.daemon.listenEvent(event, onData);
         };
         listen();