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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "23.3.6",
+  "version": "23.4.0",
   "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,
     }
   }
 
@@ -423,6 +383,7 @@ class RecordHandler {
       const record = this.getRecord(name)
 
       record.subscribe(onUpdate)
+      record.unref()
 
       if (timeout && state && record.state < state) {
         timeoutHandle = setTimeout(() => {
@@ -444,7 +405,6 @@ class RecordHandler {
 
       return () => {
         record.unsubscribe(onUpdate)
-        record.unref()
       }
     })
 

package/src/record/record.js

@@ -61,12 +61,14 @@ class Record {
 
   subscribe(fn) {
     this._subscriptions.push(fn)
+    this.ref()
   }
 
   unsubscribe(fn) {
     const idx = this._subscriptions.indexOf(fn)
     if (idx !== -1) {
       this._subscriptions.splice(idx, 1)
+      this.unref()
     }
   }
 
@@ -131,12 +133,10 @@ class Record {
         }
 
         this.unsubscribe(onUpdate)
-        this.unref()
 
         resolve(null)
       }
 
-      this.ref()
       this.subscribe(onUpdate)
     })
   }