@nxtedition/deepstream.io-client-js 23.3.6 → 23.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "23.3.6",
+  "version": "23.4.1",
   "description": "the javascript client for deepstream.io",
   "homepage": "http://deepstream.io",
   "bugs": {

package/src/default-options.js

@@ -1,11 +1,9 @@
 module.exports = {
-  heartbeatInterval: 60e3,
   reconnectIntervalIncrement: 1e3,
   maxReconnectInterval: 6e3,
   maxReconnectAttempts: Infinity,
   maxPacketSize: 512 * 1024,
   batchSize: 4096,
-  cacheSize: 4096,
   schedule: null,
   logger: null,
 }

package/src/message/connection.js

@@ -32,8 +32,6 @@ const Connection = function (client, url, options) {
   this._reconnectTimeout = null
   this._reconnectionAttempt = 0
   this._endpoint = null
-  this._lastHeartBeat = null
-  this._heartbeatInterval = null
 
   this._processingRecv = false
   this._recvMessages = this._recvMessages.bind(this)
@@ -96,7 +94,7 @@ Connection.prototype.sendMsg2 = function (topic, action, p0, p1) {
 }
 
 Connection.prototype.close = function () {
-  while (this._sendQueue.length) {
+  while (!this._sendQueue.isEmpty()) {
     this._submit(this._sendQueue.shift())
   }
   this._reset()
@@ -199,27 +197,8 @@ Connection.prototype._sendAuthParams = function () {
   this._submit(authMessage)
 }
 
-Connection.prototype._checkHeartBeat = function () {
-  const heartBeatTolerance = this._options.heartbeatInterval * 3
-
-  if (Date.now() - this._lastHeartBeat > heartBeatTolerance) {
-    clearInterval(this._heartbeatInterval)
-    this._endpoint.close()
-    const err = new Error(`heartbeat not received in the last ${heartBeatTolerance} milliseconds`)
-    this._client._$onError(C.TOPIC.CONNECTION, C.EVENT.CONNECTION_ERROR, err)
-  } else {
-    this._submit(messageBuilder.getMsg(C.TOPIC.CONNECTION, C.ACTIONS.PING))
-  }
-}
-
 Connection.prototype._onOpen = function () {
   this._clearReconnect()
-  this._lastHeartBeat = Date.now()
-  this._heartbeatInterval = setInterval(
-    this._checkHeartBeat.bind(this),
-    this._options.heartbeatInterval
-  )
-  this._heartbeatInterval.unref?.()
   this._setState(C.CONNECTION_STATE.AWAITING_CONNECTION)
 }
 
@@ -306,20 +285,13 @@ Connection.prototype._recvMessages = function (deadline) {
 }
 
 Connection.prototype._reset = function () {
-  clearInterval(this._heartbeatInterval)
-  this._heartbeatInterval = null
-  this._lastHeartBeat = null
-
   this._recvQueue = new FixedQueue()
   this._sendQueue = new FixedQueue()
 }
 
 Connection.prototype._handleConnectionResponse = function (message) {
   if (message.action === C.ACTIONS.PING) {
-    this._lastHeartBeat = Date.now()
     this._submit(messageBuilder.getMsg(C.TOPIC.CONNECTION, C.ACTIONS.PONG))
-  } else if (message.action === C.ACTIONS.PONG) {
-    this._lastHeartBeat = Date.now()
   } else if (message.action === C.ACTIONS.ACK) {
     this._setState(C.CONNECTION_STATE.AWAITING_AUTHENTICATION)
     if (this._authParams) {
@@ -394,13 +366,10 @@ Connection.prototype._tryReconnect = function () {
 
   if (this._reconnectionAttempt < this._options.maxReconnectAttempts) {
     this._setState(C.CONNECTION_STATE.RECONNECTING)
-    this._reconnectTimeout = setTimeout(
-      this._tryOpen.bind(this),
-      Math.min(
-        this._options.maxReconnectInterval,
-        this._options.reconnectIntervalIncrement * this._reconnectionAttempt
-      )
-    )
+    this._reconnectTimeout = setTimeout(() => {
+      this._reconnectTimeout = null
+      this._createEndpoint()
+    }, Math.min(this._options.maxReconnectInterval, this._options.reconnectIntervalIncrement * this._reconnectionAttempt))
     this._reconnectionAttempt++
   } else {
     this._clearReconnect()
@@ -409,14 +378,11 @@ Connection.prototype._tryReconnect = function () {
   }
 }
 
-Connection.prototype._tryOpen = function () {
-  this._createEndpoint()
-  this._reconnectTimeout = null
-}
-
 Connection.prototype._clearReconnect = function () {
-  clearTimeout(this._reconnectTimeout)
-  this._reconnectTimeout = null
+  if (this._reconnectTimeout) {
+    clearTimeout(this._reconnectTimeout)
+    this._reconnectTimeout = null
+  }
   this._reconnectionAttempt = 0
 }
 

package/src/record/record-handler.js

@@ -24,7 +24,6 @@ class RecordHandler {
     this._records = new Map()
     this._listeners = new Map()
     this._prune = new Map()
-    this._purge = new Set()
     this._patch = new Set()
     this._now = Date.now()
     this._pruning = false
@@ -34,8 +33,6 @@ class RecordHandler {
       updating: 0,
     }
 
-    this._purgeCapacity = options.cacheSize
-
     this._syncEmitter = new EventEmitter()
 
     this.set = this.set.bind(this)
@@ -52,8 +49,6 @@ class RecordHandler {
     this._client.on(C.EVENT.CONNECTED, this._onConnectionStateChange.bind(this))
 
     const prune = () => {
-      this._pruning = false
-
       let counter = 0
       for (const [rec, timestamp] of this._prune) {
         if (this._now - timestamp < 1e3) {
@@ -64,59 +59,26 @@ class RecordHandler {
           continue
         }
 
-        invariant(rec._refs === 0, 'record must have no refs')
-
         rec._unsubscribe()
 
-        this._purge.add(rec)
+        this._records.delete(rec.name)
         this._prune.delete(rec)
 
         if (counter++ > 1024) {
-          this._pruning = true
           this._schedule(prune)
           return
         }
       }
-    }
-
-    const purge = () => {
-      this._purging = false
 
-      if (!this._connected) {
-        return
-      }
-
-      let counter = 0
-      for (const rec of this._purge) {
-        if (this._purge.size < this._purgeCapacity) {
-          return
-        }
-
-        invariant(rec._refs === 0, 'record must have no refs')
-
-        this._records.delete(rec.name)
-        this._purge.delete(rec)
-
-        if (counter++ > 1024) {
-          this._purging = true
-          this._schedule(purge)
-          return
-        }
-      }
+      this._pruning = false
     }
 
     const pruneInterval = setInterval(() => {
       this._now = Date.now()
-
       if (!this._pruning) {
         this._pruning = true
         this._schedule(prune)
       }
-
-      if (!this._purging) {
-        this._purging = true
-        this._schedule(purge)
-      }
     }, 1e3)
     pruneInterval.unref?.()
   }
@@ -125,7 +87,6 @@ class RecordHandler {
     if (rec.refs === 0) {
       this._prune.set(rec, this._now)
     } else if (rec.refs === 1) {
-      this._purge.delete(rec)
       this._prune.delete(rec)
     }
   }
@@ -140,7 +101,6 @@ class RecordHandler {
       listeners: this._listeners.size,
       records: this._records.size,
       pruning: this._prune.size,
-      purging: this._purge.size,
     }
   }
 
@@ -194,13 +154,19 @@ class RecordHandler {
   }
 
   sync(options) {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
+      const timeoutValue = options?.timeout ?? 2 * 60e3
+      const signal = options?.signal
+
+      if (signal?.aborted) {
+        reject(new utils.AbortError())
+        return
+      }
+
       let done = false
       let token
-      let timeout
+      let timeoutHandle
 
-      const timeoutValue = 2 * 60e3
-      const signal = options?.signal
       const records = [...this._patch]
 
       const onDone = (val) => {
@@ -212,9 +178,9 @@ class RecordHandler {
 
         signal?.removeEventListener('abort', onAbort)
 
-        if (timeout) {
-          clearTimeout(timeout)
-          timeout = null
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle)
+          timeoutHandle = null
         }
 
         if (token) {
@@ -240,8 +206,8 @@ class RecordHandler {
       const onTimeout = () => {
         const elapsed = Date.now() - this._connected
         if (elapsed < timeoutValue) {
-          timeout = setTimeout(onTimeout, timeoutValue - elapsed)
-          timeout.unref?.()
+          timeoutHandle = setTimeout(onTimeout, timeoutValue - elapsed)
+          timeoutHandle.unref?.()
         } else {
           for (const rec of records.filter((rec) => !rec.isReady)) {
             this._client._$onError(C.TOPIC.RECORD, C.EVENT.TIMEOUT, 'record timeout', [
@@ -262,8 +228,10 @@ class RecordHandler {
         rec.ref()
       }
 
-      timeout = setTimeout(onTimeout, 2 * 60e3)
-      timeout.unref?.()
+      if (timeoutValue) {
+        timeoutHandle = setTimeout(onTimeout, timeoutValue)
+        timeoutHandle.unref?.()
+      }
 
       signal?.addEventListener('abort', onAbort)
 
@@ -337,7 +305,7 @@ class RecordHandler {
     let path
     let state = defaults ? defaults.state : undefined
     let signal
-    let timeout = defaults ? defaults.timeout : undefined
+    let timeoutValue = defaults ? defaults.timeout : undefined
     let dataOnly = defaults ? defaults.dataOnly : undefined
 
     let idx = 0
@@ -356,7 +324,7 @@ class RecordHandler {
       signal = options.signal
 
       if (options.timeout != null) {
-        timeout = options.timeout
+        timeoutValue = options.timeout
       }
 
       if (options.path != null) {
@@ -390,7 +358,11 @@ class RecordHandler {
       )
     }
 
-    let x$ = new rxjs.Observable((o) => {
+    if (signal?.aborted) {
+      return rxjs.throwError(() => new utils.AbortError())
+    }
+
+    return new rxjs.Observable((o) => {
       let timeoutHandle
       let prevData = kEmpty
 
@@ -404,8 +376,9 @@ class RecordHandler {
           timeoutHandle = null
         }
 
+        const nextData = path ? record.get(path) : record.data
+
         if (dataOnly) {
-          const nextData = record.get(path)
           if (nextData !== prevData) {
             prevData = nextData
             o.next(nextData)
@@ -414,27 +387,25 @@ class RecordHandler {
           o.next({
             name: record.name,
             version: record.version,
-            data: record.get(path),
+            data: nextData,
             state: record.state,
           })
         }
       }
 
-      const record = this.getRecord(name)
-
-      record.subscribe(onUpdate)
+      const record = this.getRecord(name).subscribe(onUpdate)
 
-      if (timeout && state && record.state < state) {
+      if (timeoutValue && state && record.state < state) {
         timeoutHandle = setTimeout(() => {
           const expected = C.RECORD_STATE_NAME[state]
           const current = C.RECORD_STATE_NAME[record.state]
           o.error(
             Object.assign(
-              new Error(`timeout after ${timeout / 1e3}s: ${name} [${current}<${expected}]`),
+              new Error(`timeout after ${timeoutValue / 1e3}s: ${name} [${current}<${expected}]`),
               { code: 'ETIMEDOUT' }
             )
           )
-        }, timeout)
+        }, timeoutValue)
         timeoutHandle.unref?.()
       }
 
@@ -442,19 +413,17 @@ class RecordHandler {
         onUpdate(record)
       }
 
-      return () => {
-        record.unsubscribe(onUpdate)
-        record.unref()
+      const abort = () => {
+        o.error(new utils.AbortError())
       }
-    })
 
-    if (signal != null) {
-      // TODO (perf): This a slow way to implement.
-      x$ = signal.aborted ? rxjs.EMPTY : x$.pipe(rx.takeUntil(rxjs.fromEvent(signal, 'abort')))
-      x$ = x$.pipe(rx.throwIfEmpty(() => new utils.AbortError()))
-    }
+      signal?.addEventListener('abort', abort)
 
-    return x$
+      return () => {
+        record.unsubscribe(onUpdate).unref()
+        signal?.removeEventListener('abort', abort)
+      }
+    })
   }
 
   _$handle(message) {

package/src/record/record.js

@@ -46,21 +46,29 @@ class Record {
 
   ref() {
     this._refs += 1
-    this._handler._onRef(this)
     if (this._refs === 1) {
       this._subscribe()
     }
+
+    this._handler._onRef(this)
+
+    return this
   }
 
   unref() {
     invariant(this._refs > 0, this._name + ' missing refs')
 
     this._refs -= 1
+
     this._handler._onRef(this)
+
+    return this
   }
 
   subscribe(fn) {
     this._subscriptions.push(fn)
+
+    return this
   }
 
   unsubscribe(fn) {
@@ -68,10 +76,12 @@ class Record {
     if (idx !== -1) {
       this._subscriptions.splice(idx, 1)
     }
+
+    return this
   }
 
   get(path) {
-    return jsonPath.get(this._data, path)
+    return path ? jsonPath.get(this._data, path) : this._data
   }
 
   set(pathOrData, dataOrNil) {
@@ -110,6 +120,7 @@ class Record {
     }
   }
 
+  // TODO (fix): timeout + signal
   when(stateOrNull) {
     invariant(this._refs > 0, this._name + ' missing refs')
 
@@ -130,8 +141,8 @@ class Record {
           return
         }
 
-        this.unsubscribe(onUpdate)
         this.unref()
+        this.unsubscribe(onUpdate)
 
         resolve(null)
       }