@tchain/tcabci-read-js-client 2.7.11 → 2.7.13

package/websocket.js

@@ -1,3 +1,4 @@
+import { byteLength, closeCode } from './validation.js'
 import { Options } from './websocketOptions.js'
 import ReconnectingWebSocket from 'reconnecting-websocket'
 
@@ -27,6 +28,9 @@ export class TWebSocket {
   _closeCallbacks = []
 
   _connectionErrorCount = 0
+  _timers = new Set()
+  _queuedMessages = 0
+  _queuedBytes = 0
 
   /**
    * @param {Options} options
@@ -44,43 +48,47 @@ export class TWebSocket {
   /**
    * @return {boolean}
    */
+  get active() {
+    return Boolean(this._client)
+  }
+
   get ready() {
     if (!this._client) return false
 
-    return this._client.readyState === WebSocket.OPEN
+    return this._client.readyState === 1
   }
 
   /**
-   * @return {Array<function>}
+   * @return {ReadonlyArray<function>}
    */
   get openListeners() {
-    return this._openCallbacks
+    return Object.freeze([...this._openCallbacks])
   }
 
   /**
-   * @return {Array<function>}
+   * @return {ReadonlyArray<function>}
    */
   get messageListeners() {
-    return this._messageCallbacks
+    return Object.freeze([...this._messageCallbacks])
   }
 
   /**
-   * @return {Array<function>}
+   * @return {ReadonlyArray<function>}
    */
   get errorListeners() {
-    return this._errorCallbacks
+    return Object.freeze([...this._errorCallbacks])
   }
 
   /**
-   * @return {Array<function>}
+   * @return {ReadonlyArray<function>}
    */
   get closeListeners() {
-    return this._closeCallbacks
+    return Object.freeze([...this._closeCallbacks])
   }
 
   /**
    * @param {?boolean} force
-   * @return {Awaited<TWebSocket>}
+   * @return {Promise<TWebSocket>}
    * @throws {Error}
    */
   async connect(force = false) {
@@ -92,31 +100,57 @@ export class TWebSocket {
 
   /**
    * @param {?number} code
-   * @return {Awaited<TWebSocket>}
+   * @return {Promise<TWebSocket>}
    * @throws {Error}
    */
   async reconnect(code = null) {
-    await this._disconnect(code)
-    this._init(true)
+    this._close(code)
+    await this._init(true)
 
     return this
   }
 
   /**
-   * @param {number} code
-   * @return {Promise<void>}
+   * Close every socket state, clear queued callbacks and release references.
+   * @param {number} [code=1000]
+   * @returns {Promise<void>}
    */
   async disconnect(code = 1000) {
     return this._disconnect(code)
   }
 
   /**
+   * Send a bounded message. Offline binary buffers are rejected, not retained.
    * @param {string|ArrayBuffer|Blob|ArrayBufferView} msg
+   * @returns {void}
    */
   send(msg) {
-    if (!this._client) return
+    if (!this._client) throw new Error('Not connected')
+
+    const size = byteLength(msg)
+
+    if (size > this._options.maxMessageBytes)
+      throw new Error('Message exceeds limit')
+
+    if (!this.ready && typeof msg !== 'string')
+      throw new Error('Binary messages require an open connection')
+
+    if (this.ready) {
+      if (this._client.bufferedAmount + size > this._options.maxMessageBytes)
+        throw new Error('Outgoing buffer exceeds byte limit')
+    } else if (
+      this._queuedMessages >= this._options.maxEnqueuedMessages ||
+      this._queuedBytes + size > this._options.maxMessageBytes
+    ) {
+      throw new Error('Outgoing queue exceeds limit')
+    }
 
     this._client.send(msg)
+
+    if (!this.ready) {
+      this._queuedMessages++
+      this._queuedBytes += size
+    }
   }
 
   /**
@@ -194,10 +228,12 @@ export class TWebSocket {
    * @private
    */
   _addListener(name, callback) {
+    if (typeof callback !== 'function') throw new TypeError('Invalid callback')
+
     if (this[name].length >= MaxListenerSize)
       throw new Error(`listener size must be ${MaxListenerSize}`)
 
-    if (this[name].findIndex(v => v === callback) > -1) return this
+    if (this[name].findIndex((v) => v === callback) > -1) return this
 
     this[name].push(callback)
 
@@ -210,7 +246,7 @@ export class TWebSocket {
    * @private
    */
   _removeListener(name, callback) {
-    const idx = this[name].findIndex(v => v === callback)
+    const idx = this[name].findIndex((v) => v === callback)
 
     if (idx > -1) {
       this[name].splice(idx, 1)
@@ -222,30 +258,43 @@ export class TWebSocket {
   _callListener(name, value) {
     if (!this[name]) return
 
+    if (
+      this._timers.size + this[name].length >
+      this._options.maxPendingCallbacks
+    ) {
+      this._fail(4008)
+
+      return
+    }
+
     for (const callback of this[name]) {
-      setTimeout(
-        (callback, value) => {
+      const timer = setTimeout(() => {
+        this._timers.delete(timer)
+
+        if (!this[name].includes(callback)) return
+
+        try {
           callback(value)
-        },
-        0,
-        callback,
-        value
-      )
+        } catch {
+          if (name !== '_errorCallbacks')
+            this._onError(new Error('Callback failed'))
+        }
+      }, 0)
+
+      this._timers.add(timer)
     }
   }
 
   /**
    * @private
    * @param {?boolean} force
-   * @return {Awaited<TWebSocket>}
+   * @return {Promise<TWebSocket>}
    * @throws {Error}
    */
   async _init(force = false) {
-    if (!force && this.ready) return this
+    if (!force && this._client) return this
 
-    if (this.ready) {
-      await this.disconnect(1000)
-    }
+    if (this._client) this._close(1000)
 
     this._make()
 
@@ -261,32 +310,36 @@ export class TWebSocket {
       this._options.make()
     )
 
-    this._openListener = e => {
+    this._openListener = (e) => {
+      this._queuedMessages = 0
+      this._queuedBytes = 0
       this._connectionErrorCount = 0
       this._onOpen(e)
     }
     this._client.addEventListener('open', this._openListener)
 
-    this._closeListener = e => {
+    this._closeListener = (e) => {
       this._onClose(e)
     }
     this._client.addEventListener('close', this._closeListener)
 
-    this._messageListener = e => {
+    this._messageListener = (e) => {
       this._onMessage(e)
     }
     this._client.addEventListener('message', this._messageListener)
 
-    this._errorListener = e => {
+    this._errorListener = (e) => {
       this._onError(e)
+
       if (this._connectionErrorCount > 15) {
         this._onError(new Error('Internet connectivity problem!'))
-        this._disconnect().catch(err => {
+        this._disconnect().catch((err) => {
           this._onError(err)
         })
 
         return
       }
+
       this._connectionErrorCount++
     }
     this._client.addEventListener('error', this._errorListener)
@@ -298,18 +351,39 @@ export class TWebSocket {
    * @return {Promise<void>}
    */
   async _disconnect(code = 1000) {
-    if (!this.ready) return
+    this._close(code)
+  }
+
+  _fail(code) {
+    const callbacks = [...this._closeCallbacks]
 
     this._close(code)
+
+    for (const callback of callbacks) {
+      try {
+        callback({ code, reason: 'Connection limit exceeded', wasClean: false })
+      } catch {
+        /* No payload logging. */
+      }
+    }
   }
 
   _close(code = 1000) {
-    if (!code) code = 1000
+    code = closeCode(code)
+    this._queuedMessages = 0
+    this._queuedBytes = 0
+
+    for (const timer of this._timers) clearTimeout(timer)
 
-    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._timers.clear()
+
+    const client = this._client
+
+    this._client = undefined
+    client?.removeEventListener('open', this._openListener)
+    client?.removeEventListener('close', this._closeListener)
+    client?.removeEventListener('message', this._messageListener)
+    client?.removeEventListener('error', this._errorListener)
 
     this._openCallbacks.length = 0
     this._errorCallbacks.length = 0
@@ -318,10 +392,10 @@ export class TWebSocket {
 
     this._openListener = () => {}
     this._closeListener = () => {}
-    this._closeListener = () => {}
+    this._errorListener = () => {}
     this._messageListener = () => {}
 
-    this._client.close(code)
+    client?.close(code)
     this._connectionErrorCount = 0
   }
 
@@ -346,6 +420,18 @@ export class TWebSocket {
    * @private
    */
   _onMessage(msg) {
+    try {
+      if (byteLength(msg.data) > this._options.maxMessageBytes) {
+        this._fail(4009)
+
+        return
+      }
+    } catch {
+      this._fail(4003)
+
+      return
+    }
+
     this._callListener('_messageCallbacks', msg)
   }
 

package/websocketOptions.d.ts

@@ -1,40 +1,78 @@
+import { WebSocketConstructor } from './types.js'
+
 export declare type Timeout = number
+
 export declare const DefaultTimeout: Timeout, LongTimeout: Timeout
 
 export declare type Port = number
+
 export declare const HTTPSPort: Port, HTTPPort: Port
 
 export declare class Options {
   constructor(
     host: string,
-    timeout: Timeout,
-    secure: boolean,
-    port: Port,
-    longpoll: boolean
+    timeout?: Timeout,
+    secure?: boolean,
+    port?: Port,
+    longpoll?: boolean
   )
+
+  setAllowInsecure(value: boolean): this
+
+  setMaxMessageBytes(value: number): this
+
+  get maxMessageBytes(): number
+
+  setMaxPendingCallbacks(value: number): this
+
+  get maxPendingCallbacks(): number
+
   check(): boolean
-  isLongPool(): boolean
+
+  get isLongPool(): boolean
+
   setDebug(debug: boolean): Options
+
   get debug(): boolean
-  setEndpoints(wsEndpoint: string, longpollEndpoint: string): Options
-  endpoints(): string[]
+
+  setEndpoints(wsEndpoint?: string, longpollEndpoint?: string): Options
+
+  get endpoints(): readonly string[]
+
   setMaxConnectionDelay(delay: number): Options
+
   get maxConnectionDelay(): number
+
   setMinReconnectionDelay(delay: number): Options
+
   get minReconnectionDelay(): number
+
   setReconnectionDelayGrowFactor(gw: number): Options
+
   get reconnectionDelayGrowFactor(): number
+
   setMinUptime(ut: number): Options
+
   get minUptime(): number
+
   setMaxRetries(retries: number): Options
+
   get maxRetries(): number
+
   setMaxEnqueuedMessages(em: number): Options
+
   get maxEnqueuedMessages(): number
+
   setProtocols(protocols: string[]): Options
-  get protocols(): string[]
-  setCustomWS(customWS: WebSocket): Options
-  get customWS(): WebSocket | undefined
+
+  get protocols(): readonly string[]
+
+  setCustomWS(customWS: WebSocketConstructor): Options
+
+  get customWS(): WebSocketConstructor | undefined
+
   get url(): string
+
   make(): {
     WebSocket?: any
     maxReconnectionDelay: number

package/websocketOptions.js

@@ -1,9 +1,8 @@
-import { Debug } from '@streetbyters/js-debug'
+import { CLIENT_VERSION, endpoint, positiveInteger } from './validation.js'
 
 export const HTTPSPort = 443,
-  HTTPPort = 80
-
-export const DefaultTimeout = 7000,
+  HTTPPort = 80,
+  DefaultTimeout = 7000,
   LongTimeout = DefaultTimeout * 2
 
 export class Options {
@@ -15,14 +14,17 @@ export class Options {
   _protocols = []
   _customWS
   _endpoints = ['ws', 'longpoll']
-  _version = `v2.7.11`
+  _version = CLIENT_VERSION
+  _allowInsecure = false
+  _maxMessageBytes = 16 * 1024 * 1024
+  _maxPendingCallbacks = 1000
 
   _maxConnectionDelay = 10000
   _minReconnectionDelay = 1000 + Math.random() * 4000
   _reconnectionDelayGrowFactor = 1.3
   _minUptime = 5000
   _maxRetries = 10
-  _maxEnqueuedMessages = Infinity
+  _maxEnqueuedMessages = 100
   _startClosed = false
   _debug = false
 
@@ -56,15 +58,36 @@ export class Options {
     if (this._timeout > LongTimeout)
       throw new Error(`timeout less than LongTimeout`)
 
-    // eslint-disable-next-line
-    try {
-      new URL(this.url)
+    positiveInteger(this._timeout, 'timeout')
+    endpoint(this.url, ['ws:', 'wss:'], this._allowInsecure)
 
-      return true
-    } catch (e) {
-      Debug.error(e)
-      throw e
-    }
+    return true
+  }
+
+  setAllowInsecure(value) {
+    this._allowInsecure = value === true
+
+    return this
+  }
+
+  setMaxMessageBytes(value) {
+    this._maxMessageBytes = positiveInteger(value, 'maxMessageBytes')
+
+    return this
+  }
+
+  get maxMessageBytes() {
+    return this._maxMessageBytes
+  }
+
+  setMaxPendingCallbacks(value) {
+    this._maxPendingCallbacks = positiveInteger(value, 'maxPendingCallbacks')
+
+    return this
+  }
+
+  get maxPendingCallbacks() {
+    return this._maxPendingCallbacks
   }
 
   /**
@@ -108,10 +131,10 @@ export class Options {
   }
 
   /**
-   * @return {Array<string>}
+   * @return {ReadonlyArray<string>}
    */
   get endpoints() {
-    return this._endpoints
+    return Object.freeze([...this._endpoints])
   }
 
   /**
@@ -204,7 +227,7 @@ export class Options {
    * @return {Options}
    */
   setMaxEnqueuedMessages(em) {
-    this._maxEnqueuedMessages = em
+    this._maxEnqueuedMessages = positiveInteger(em, 'maxEnqueuedMessages')
 
     return this
   }
@@ -222,18 +245,22 @@ export class Options {
    * @throws {TypeError}
    */
   setProtocols(protocols) {
-    if (!Array.isArray(protocols))
+    if (
+      !Array.isArray(protocols) ||
+      protocols.some((v) => typeof v !== 'string')
+    )
       throw new TypeError('protocols must be a Array')
-    this._protocols = protocols
+
+    this._protocols = [...protocols]
 
     return this
   }
 
   /**
-   * @return {Array<string>}
+   * @return {ReadonlyArray<string>}
    */
   get protocols() {
-    return this._protocols
+    return Object.freeze([...this._protocols])
   }
 
   /**
@@ -257,7 +284,9 @@ export class Options {
    * @return {string}
    */
   get url() {
-    if (this._host.length > 2 && this._host.slice(0, 2) === 'ws') {
+    if (typeof this._host !== 'string') throw new TypeError('Invalid host')
+
+    if (/^wss?:\/\//.test(this._host)) {
       return `${this._host}${![HTTPPort, HTTPSPort].includes(this._port) ? `:${this._port}` : ''}`
     }
 
@@ -278,7 +307,8 @@ export class Options {
       maxRetries: this._maxRetries,
       maxEnqueuedMessages: this._maxEnqueuedMessages,
       startClosed: this._startClosed,
-      debug: this._debug,
+      // ReconnectingWebSocket debug logs outgoing payloads. Never enable it.
+      debug: false,
       headers: {
         Client: `tcabaci-read-js-client/${this._version}`
       }