@tchain/tcabci-read-js-client 2.4.0 → 2.5.0

package/websocketOptions.js

@@ -0,0 +1,277 @@
+export const HTTPSPort = 443,
+  HTTPPort = 80
+
+export const DefaultTimeout = 7000,
+  LongTimeout = DefaultTimeout * 2
+
+export class Options {
+  _host
+  _port
+  _secure
+  _timeout
+  _longpoll = false
+  _protocols = []
+  _customWS
+  _endpoints = ['ws', 'longpoll']
+
+  _maxConnectionDelay = 10000
+  _minReconnectionDelay = 1000 + Math.random() * 4000
+  _reconnectionDelayGrowFactor = 1.3
+  _minUptime = 5000
+  _maxRetries = 10
+  _maxEnqueuedMessages = Infinity
+  _startClosed = false
+  _debug = !!process.env.DEBUG
+
+  /**
+   * @param {string} host
+   * @param {?number} timeout
+   * @param {?boolean} secure
+   * @param {?number} port
+   * @param {?boolean} longpoll
+   * @constructor
+   */
+  constructor(
+    host,
+    timeout = DefaultTimeout,
+    secure = true,
+    port = HTTPSPort,
+    longpoll = false,
+  ) {
+    this._host = host
+    this._port = port
+    this._secure = secure
+    this._timeout = timeout
+    this._longpoll = longpoll
+  }
+
+  /**
+   * @return {boolean}
+   * @throws {Error}
+   */
+  check() {
+    if (this._timeout > LongTimeout)
+      throw new Error(`timeout less than LongTimeout`)
+
+    try {
+      new URL(this.url())
+
+      return true
+    } catch (e) {
+      throw e
+    }
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isLongPool() {
+    // return this._longpoll
+
+    return false
+  }
+
+  /**
+   * @param {boolean} debug
+   * @return {Options}
+   */
+  setDebug(debug) {
+    this._debug = debug
+
+    return this
+  }
+
+  /**
+   * @return {boolean}
+   */
+  debug() {
+    return this._debug
+  }
+
+  /**
+   * @param {?string} wsEndpoint
+   * @param {?string} longpollEndpoint
+   * @throws {Error}
+   */
+  setEndpoints(wsEndpoint = 'ws', longpollEndpoint = 'longpool') {
+    if (typeof wsEndpoint !== 'string' || typeof longpollEndpoint !== 'string')
+      throw new TypeError('invalid endpoints')
+
+    this._endpoints = [wsEndpoint, longpollEndpoint]
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  endpoints() {
+    return this._endpoints
+  }
+
+  /**
+   * @param {number} delay
+   * @return {Options}
+   */
+  setMaxConnectionDelay(delay) {
+    this._maxConnectionDelay = delay
+
+    return this
+  }
+
+  /**
+   * @return {number}
+   */
+  maxConnectionDelay() {
+    return this._maxConnectionDelay
+  }
+
+  /**
+   * @param {number} delay
+   * @return {Options}
+   */
+  setMinReconnectionDelay(delay) {
+    this._minReconnectionDelay = delay
+
+    return this
+  }
+
+  /**
+   * @return {number}
+   */
+  minReconnectionDelay() {
+    return this._minReconnectionDelay
+  }
+
+  /**
+   * @param {number} gw
+   * @return {Options}
+   */
+  setReconnectionDelayGrowFactor(gw) {
+    this._reconnectionDelayGrowFactor = gw
+
+    return this
+  }
+
+  /**
+   * @return {number}
+   */
+  reconnectionDelayGrowFactor() {
+    return this._reconnectionDelayGrowFactor
+  }
+
+  /**
+   * @param {number} ut
+   * @return {Options}
+   */
+  setMinUptime(ut) {
+    this._minUptime = ut
+
+    return this
+  }
+
+  /**
+   * @return {number}
+   */
+  minUptime() {
+    return this._minUptime
+  }
+
+  /**
+   * @param {number} retries
+   * @return {Options}
+   */
+  setMaxRetries(retries) {
+    this._maxRetries = retries
+
+    return this
+  }
+
+  /**
+   * @return {number}
+   */
+  maxRetries() {
+    return this._maxRetries
+  }
+
+  /**
+   * @param {number} em
+   * @return {Options}
+   */
+  setMaxEnqueuedMessages(em) {
+    this._maxEnqueuedMessages = em
+
+    return this
+  }
+
+  /**
+   * @return {number}
+   */
+  maxEnqueuedMessages() {
+    return this._maxEnqueuedMessages
+  }
+
+  /**
+   * @param {Array<string>} protocols
+   * @return {Options}
+   * @throws {TypeError}
+   */
+  setProtocols(protocols) {
+    if (!Array.isArray(protocols))
+      throw new TypeError('protocols must be a Array')
+    this._protocols = protocols
+
+    return this
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  protocols() {
+    return this._protocols
+  }
+
+  /**
+   * @param {any} customWS
+   * @return {Options}
+   */
+  setCustomWS(customWS) {
+    this._customWS = customWS
+
+    return this
+  }
+
+  /**
+   * @return {any}
+   */
+  customWS() {
+    return this._customWS
+  }
+
+  /**
+   * @return {string}
+   */
+  url() {
+    if (this._host.length > 2 && this._host.slice(0, 2) === 'ws') {
+      return `${this._host}${![HTTPPort, HTTPSPort].includes(this._port) ? `:${this._port}` : ''}`
+    }
+
+    return `ws${this._secure ? 's' : ''}://${this._host}${![HTTPPort, HTTPSPort].includes(this._port) ? `:${this._port}` : ''}/${!this._longpoll ? this._endpoints[0] : this._endpoints[1]}`
+  }
+
+  /**
+   * @return {{WebSocket: ?any, maxReconnectionDelay: number, minReconnectionDelay: number, reconnectionDelayGrowFactor: number, minUptime: number, connectionTimeout: number, maxRetries: number, maxEnqueuedMessages: number, startClosed: boolean, debug: boolean }}
+   */
+  make() {
+    return {
+      ...(this._customWS ? { WebSocket: this._customWS } : {}),
+      maxReconnectionDelay: this._maxConnectionDelay,
+      minReconnectionDelay: this._minReconnectionDelay,
+      reconnectionDelayGrowFactor: this._reconnectionDelayGrowFactor,
+      minUptime: this._minUptime,
+      connectionTimeout: this._timeout,
+      maxRetries: this._maxRetries,
+      maxEnqueuedMessages: this._maxEnqueuedMessages,
+      startClosed: this._startClosed,
+      debug: this._debug,
+    }
+  }
+}

package/websocketOptions_test.js

@@ -0,0 +1,129 @@
+import { describe, it } from 'mocha'
+import { expect } from 'chai'
+import { DefaultTimeout, HTTPPort, HTTPSPort, Options } from './websocketOptions.js'
+import WebSocket from 'ws'
+
+describe('Options', () => {
+  it('HTTPSPort', () => {
+    expect(HTTPSPort).to.equal(443)
+  })
+
+  it('HTTPPort', () => {
+    expect(HTTPPort).to.equal(80)
+  })
+
+  it('constructor/1', () => {
+    const options = new Options('localhost')
+
+    expect(options).to.be.an.instanceOf(Options)
+  })
+
+  it('check/0 with valid params', () => {
+    const options = new Options('localhost')
+
+    expect(options.check()).to.be.equal(true)
+  })
+
+  it('should error check/0 with invalid params', () => {
+    const options = new Options(1)
+
+    expect(options.check).to.throw(Error)
+  })
+
+  it('should error check/0 if exceeded timeout', () => {
+    const options = new Options('localhost', 20000)
+
+    expect(options.check).to.throw(Error)
+  })
+
+  it('isLongPoll/0', () => {
+    const options = new Options('localhost')
+
+    expect(options.isLongPool()).to.be.equal(false)
+  })
+
+  it('setEndpoints/2 with valid params', () => {
+    const options = new Options('localhost')
+
+    expect(() => {
+      options.setEndpoints('e1', 'e2')
+    }).to.not.throw(Error)
+  })
+
+  it('should error setEndpoints/2 with invalid params', () => {
+    const options = new Options('localhost')
+
+    expect(() => {
+      options.setEndpoints(1, false)
+    }).to.throw(Error)
+  })
+
+  it('setProtocols/1 with valid params', () => {
+    const options = new Options('localhost')
+
+    expect(options.setProtocols(['soap'])).to.be.eq(options)
+  })
+
+  it('should error setProtocols/1 with invalid params', () => {
+    const options = new Options('localhost')
+
+    expect(() => {
+      options.setProtocols('invalid')
+    }).to.throw(Error)
+  })
+
+  it('protocols/0', () => {
+    const options = new Options('localhost')
+
+    options.setProtocols(['wamp', 'soap'])
+    expect(options.protocols()).to.have.deep.members(['wamp', 'soap'])
+  })
+
+  it('setCustomWS/1 with valid params', () => {
+    const options = new Options('localhost')
+
+    expect(options.setCustomWS(WebSocket)).to.be.eq(options)
+  })
+
+  it('customWS/0', () => {
+    const options = new Options('localhost')
+
+    options.setCustomWS(WebSocket)
+    expect(options.customWS()).to.be.eq(WebSocket)
+  })
+
+  it('url/0', () => {
+    const options = new Options('localhost.localdomain')
+
+    expect(options.url()).to.equal('wss://localhost.localdomain/ws')
+  })
+
+  it('url/0 with protocol', () => {
+    const options = new Options('ws://localhost.localdomain')
+
+    expect(options.url()).to.equal('ws://localhost.localdomain')
+  })
+
+  it('url/0 with protocol case two', () => {
+    const options = new Options('wss://localhost.localdomain/ws')
+
+    expect(options.url()).to.equal('wss://localhost.localdomain/ws')
+  })
+
+  it('make/0', () => {
+    const options = new Options('localhost.io')
+    options.setDebug(true)
+
+    const opts = options.make()
+
+    expect(opts.maxReconnectionDelay).to.be.eq(10000)
+    expect(opts.minReconnectionDelay).to.be.at.least(1000)
+    expect(opts.reconnectionDelayGrowFactor).to.be.eq(1.3)
+    expect(opts.minUptime).to.be.eq(5000)
+    expect(opts.connectionTimeout).to.be.eq(DefaultTimeout)
+    expect(opts.maxRetries).to.be.eq(10)
+    expect(opts.maxEnqueuedMessages).to.be.eq(Infinity)
+    expect(opts.startClosed).to.be.eq(false)
+    expect(opts.debug).to.be.eq(true)
+  })
+})