Class ReconnectingClient

The connection sequence looks like follows:

const client = new ReconnectingClient() // creates an instance
                🠗
      client.register('method1', handler1);
      await client.init()
      client.register('method2', handler2);
 // inits the connection:
 // ⌛ client now tries to connect to the server
                🠗
 // when the client establishes a websocket connection, it can
 // 🛑 reject the promise and emits `connectError` event if server refuses
 //   the client to connect with its token. Thus it stops any connection
 //   attempts until you execute `init` method again.
 // 👌 resolve the promise and emits `connect` event if the server accepts
 //   the connection.
                🠗
      await client.call('serverMethod' {...args});
      client.register('method3', handler3);
 // ⚡ if everything is 👌, here you can call server's methods. Note that when
 // the client isn't connected every execution of the `call` method will
 // throw an error.
                🠗
    client.addEventListener('connect', () => {console.log('😃')});
    client.addEventListener('connectError', () => {console.error('😟')});
 // 💥 when the connection to the server breaks, an `close`event will be
 // raised
 // ⌛ and the client will try to connect to the server again
 // At this point you can check the connection status via `connect` or
 // `connectError` events.
 // And, as you can see, you can register client rpc-methods everywhere in
 // the code after calling the constructor. And this methods along with
 // the events will be connected to every new inner instance of the
 // Client class

This class can register any method to call it by the server. And also can call any method on the server and receive response data. And there are some events that can help you.

The main parts of this class are:

• init method to connect to the server
• close event that triggers when connection to the server is lost
• connect event that triggers when the client successfully reconnects to the server
• connectError event that triggers when the server refuses the client to connect
• register method to handle clients' calls
• call method to execute clients' methods

example

import { ReconnectingClient } from '@noveo/dual-rpc-ws/client';
const client = new ReconnectingClient({
  token: 'id13',
  address: 'ws://192.168.0.80:8080'
});
try {
  await client.init();
  console.log('successfully connected for the first time!');
  client.register('hi', (params, context) => {
    console.log('client hi, call id:', context.id);
    return Promise.resolve(`${token}, hello`);
  });
  client.addEventListener('connect', () => {
    console.log('successfully reconnected!');
  });
  client.addEventListener('connectError', () => {
    console.error('server refuses to reconnect!');
  });
  client.addEventListener('close', () => {
    console.log('connection closed!');
  });
  try {
    const serverResponse = client.call('hi', {message: 'Server, hi!'});
    console.log('Hello from server', serverResponse);
  } catch(e) {
    console.error('Trouble with call', e.message);
  }
} catch(e) {
  console.error('server refuses to connect!')
}