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

package/websocket.js

@@ -0,0 +1,344 @@
+import { Options } from './websocketOptions.js'
+import ReconnectingWebSocket from 'reconnecting-websocket'
+
+export const MaxListenerSize = 100
+
+export class TWebSocket {
+  /**
+   * @private
+   * @type {Options}
+   */
+  _options
+
+  /**
+   * @private
+   * @type {ReconnectingWebSocket}
+   */
+  _client
+
+  _openListener = () => {}
+  _messageListener = () => {}
+  _errorListener = () => {}
+  _closeListener = () => {}
+
+  _openCallbacks = []
+  _messageCallbacks = []
+  _errorCallbacks = []
+  _closeCallbacks = []
+
+  /**
+   * @param {Options} options
+   * @constructor
+   * @throws {Error}
+   */
+  constructor(options) {
+    if (!(options instanceof Options))
+      throw new TypeError('options must be a Options')
+
+    options.check()
+    this._options = options
+  }
+
+  /**
+   * @return {boolean}
+   */
+  get ready() {
+    if (!this._client) return false
+
+    return this._client.readyState === WebSocket.OPEN
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  get openListeners() {
+    return this._openCallbacks
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  get messageListeners() {
+    return this._messageCallbacks
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  get errorListeners() {
+    return this._errorCallbacks
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  get closeListeners() {
+    return this._closeCallbacks
+  }
+
+  /**
+   * @param {?boolean} force
+   * @return {Awaited<TWebSocket>}
+   * @throws {Error}
+   */
+  async connect(force = false) {
+    if (!force && this.ready)
+      throw new Error('already connect. please use force flag')
+
+    return this._init(force)
+  }
+
+  /**
+   * @param {?number} code
+   * @return {Awaited<TWebSocket>}
+   * @throws {Error}
+   */
+  async reconnect(code = null) {
+    await this._disconnect(code)
+    this._init(true)
+
+    return this
+  }
+
+  /**
+   * @param {number} code
+   * @return {Promise<void>}
+   */
+  async disconnect(code = 1000) {
+    return this._disconnect(code)
+  }
+
+  /**
+   * @param {string|ArrayBuffer|Blob|ArrayBufferView} msg
+   */
+  send(msg) {
+    if (!this._client) return
+
+    this._client.send(msg)
+  }
+
+  /**
+   * @param {function(Event)} callback
+   * @return {TWebSocket}
+   * @throws {Error}
+   */
+  addOpenListener(callback) {
+    return this._addListener('_openCallbacks', callback)
+  }
+
+  /**
+   * @param {function(Event)} callback
+   * @return {TWebSocket}
+   */
+  removeOpenListener(callback) {
+    return this._removeListener('_openCallbacks', callback)
+  }
+
+  /**
+   * @param {function(MessageEvent)} callback
+   * @return {TWebSocket}
+   * @throws {Error}
+   */
+  addMessageListener(callback) {
+    return this._addListener('_messageCallbacks', callback)
+  }
+
+  /**
+   * @param {function(MessageEvent)} callback
+   * @return {TWebSocket}
+   */
+  removeMessageListener(callback) {
+    return this._removeListener('_messageCallbacks', callback)
+  }
+
+  /**
+   * @param {function(ErrorEvent)} callback
+   * @return {TWebSocket}
+   * @throws {Error}
+   */
+  addErrorListener(callback) {
+    return this._addListener('_errorCallbacks', callback)
+  }
+
+  /**
+   * @param {function(ErrorEvent)} callback
+   * @return {TWebSocket}
+   */
+  removeErrorListener(callback) {
+    return this._removeListener('_errorCallbacks', callback)
+  }
+
+  /**
+   * @param {function(CloseEvent)} callback
+   * @return {TWebSocket}
+   * @throws {Error}
+   */
+  addCloseListener(callback) {
+    return this._addListener('_closeCallbacks', callback)
+  }
+
+  /**
+   * @param {function(CloseEvent)} callback
+   * @return {TWebSocket}
+   */
+  removeCloseListener(callback) {
+    return this._removeListener('_closeCallbacks', callback)
+  }
+
+  /**
+   * @param {string} name
+   * @param {function(any)} callback
+   * @throws {Error}
+   * @private
+   */
+  _addListener(name, callback) {
+    if (this[name].length >= MaxListenerSize)
+      throw new Error(`listener size must be ${MaxListenerSize}`)
+
+    if (this[name].findIndex((v) => v === callback) > -1) return this
+
+    this[name].push(callback)
+
+    return this
+  }
+
+  /**
+   * @param {string} name
+   * @param {function(any)} callback
+   * @private
+   */
+  _removeListener(name, callback) {
+    const idx = this[name].findIndex((v) => v === callback)
+
+    if (idx > -1) {
+      this[name].splice(idx, 1)
+    }
+
+    return this
+  }
+
+  _callListener(name, value) {
+    if (!this[name]) return
+
+    for (const callback of this[name]) {
+      setTimeout(
+        (callback, value) => {
+          callback(value)
+        },
+        0,
+        callback,
+        value,
+      )
+    }
+  }
+
+  /**
+   * @private
+   * @param {?boolean} force
+   * @return {Awaited<TWebSocket>}
+   * @throws {Error}
+   */
+  async _init(force = false) {
+    if (!force && this.ready) return this
+
+    if (this.ready) {
+      await this.disconnect(1000)
+    }
+
+    this._make()
+
+    return this
+  }
+
+  _make() {
+    this._client = new ReconnectingWebSocket(
+      this._options.url(),
+      this._options.protocols(),
+      this._options.make(),
+    )
+
+    this._openListener = (e) => {
+      this._onOpen(e)
+    }
+    this._client.addEventListener('open', this._openListener)
+
+    this._closeListener = (e) => {
+      this._onClose(e)
+    }
+    this._client.addEventListener('close', this._closeListener)
+
+    this._messageListener = (e) => {
+      this._onMessage(e)
+    }
+    this._client.addEventListener('message', this._messageListener)
+
+    this._errorListener = (e) => {
+      this._onError(e)
+    }
+    this._client.addEventListener('error', this._errorListener)
+  }
+
+  /**
+   * @private
+   * @param {?number} code
+   * @return {Promise<void>}
+   */
+  async _disconnect(code = 1000) {
+    if (!this.ready) return
+
+    this._close(code)
+  }
+
+  _close(code = 1000) {
+    if (!code) code = 1000
+
+    this._client.removeEventListener('open', this._openListener)
+    this._client.removeEventListener('close', this._closeListener)
+    this._client.removeEventListener('message', this._messageListener)
+    this._client.removeEventListener('error', this._errorListener)
+
+    this._openCallbacks.length = 0
+    this._errorCallbacks.length = 0
+    this._closeCallbacks.length = 0
+    this._messageCallbacks.length = 0
+
+    this._openListener = () => {}
+    this._closeListener = () => {}
+    this._closeListener = () => {}
+    this._messageListener = () => {}
+
+    this._client.close(code)
+  }
+
+  /**
+   * @param {CloseEvent} event
+   * @private
+   */
+  _onClose(event) {
+    this._callListener('_closeCallbacks', event)
+  }
+
+  /**
+   * @param {ErrorEvent} event
+   * @private
+   */
+  _onError(event) {
+    this._callListener('_errorCallbacks', event)
+  }
+
+  /**
+   * @param {MessageEvent} msg
+   * @private
+   */
+  _onMessage(msg) {
+    this._callListener('_messageCallbacks', msg)
+  }
+
+  /**
+   * @param {Event} event
+   * @private
+   */
+  _onOpen(event) {
+    this._callListener('_openCallbacks', event)
+  }
+}

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,
+    }
+  }
+}