@nxtedition/deepstream.io-client-js 23.4.53 → 23.4.54

package/package.json

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

package/src/message/connection.js

@@ -21,7 +21,6 @@ const Connection = function (client, url, options) {
   this._tooManyAuthAttempts = false
   this._connectionAuthenticationTimeout = false
   this._challengeDenied = false
-  this._sendQueue = new FixedQueue()
   this._message = {
     raw: null,
     topic: null,
@@ -35,8 +34,6 @@ const Connection = function (client, url, options) {
 
   this._processingRecv = false
   this._recvMessages = this._recvMessages.bind(this)
-  this._processingSend = false
-  this._sendMessages = this._sendMessages.bind(this)
 
   this._url = new URL(url)
 
@@ -82,22 +79,18 @@ Connection.prototype.authenticate = function (authParams, callback) {
 }
 
 Connection.prototype.sendMsg = function (topic, action, data) {
-  this.send(messageBuilder.getMsg(topic, action, data))
+  return this.send(messageBuilder.getMsg(topic, action, data))
 }
 
 Connection.prototype.sendMsg1 = function (topic, action, p0) {
-  this.send(messageBuilder.getMsg1(topic, action, p0))
+  return this.send(messageBuilder.getMsg1(topic, action, p0))
 }
 
 Connection.prototype.sendMsg2 = function (topic, action, p0, p1) {
-  this.send(messageBuilder.getMsg2(topic, action, p0, p1))
+  return this.send(messageBuilder.getMsg2(topic, action, p0, p1))
 }
 
 Connection.prototype.close = function () {
-  while (!this._sendQueue.isEmpty()) {
-    this._submit(this._sendQueue.shift())
-  }
-  this._reset()
   this._deliberateClose = true
   this._endpoint?.close()
 
@@ -133,48 +126,10 @@ Connection.prototype.send = function (message) {
       err,
       message.split(C.MESSAGE_PART_SEPERATOR).map((x) => x.slice(0, 256))
     )
-    return
-  }
-
-  if (this._processingSend) {
-    this._sendQueue.push(message)
-  } else if (
-    this._state === C.CONNECTION_STATE.OPEN &&
-    this._endpoint.readyState === this._endpoint.OPEN
-  ) {
-    this._submit(message)
-  } else {
-    this._sendQueue.push(message)
-    this._processingSend = true
-    this._sendMessages()
-  }
-}
-
-Connection.prototype._sendMessages = function (deadline) {
-  if (
-    this._state !== C.CONNECTION_STATE.OPEN ||
-    this._endpoint.readyState !== this._endpoint.OPEN
-  ) {
-    this._processingSend = false
-    return
-  }
-
-  for (
-    let n = 0;
-    // eslint-disable-next-line no-unmodified-loop-condition
-    n < this._batchSize && (!deadline || deadline.timeRemaining() || deadline.didTimeout);
-    ++n
-  ) {
-    const message = this._sendQueue.shift()
-    if (!message) {
-      this._processingSend = false
-      return
-    }
-
-    this._submit(message)
+    return false
   }
 
-  this._schedule(this._sendMessages)
+  return this._submit(message)
 }
 
 Connection.prototype._submit = function (message) {
@@ -183,12 +138,18 @@ Connection.prototype._submit = function (message) {
   if (message.length > maxPacketSize) {
     const err = new Error(`Packet to big: ${message.length} > ${maxPacketSize}`)
     this._client._$onError(C.TOPIC.CONNECTION, C.EVENT.CONNECTION_ERROR, err)
-  } else if (this._endpoint.readyState === this._endpoint.OPEN) {
+    return false
+  } else if (
+    this._state === C.CONNECTION_STATE.OPEN &&
+    this._endpoint.readyState === this._endpoint.OPEN
+  ) {
     this.emit('send', message)
     this._endpoint.send(message)
+    return true
   } else {
     const err = new Error('Tried to send message on a closed websocket connection')
     this._client._$onError(C.TOPIC.CONNECTION, C.EVENT.CONNECTION_ERROR, err)
+    return false
   }
 }
 
@@ -210,7 +171,7 @@ Connection.prototype._onOpen = function () {
 }
 
 Connection.prototype._onError = function (err) {
-  this._reset()
+  this._recvMessages()
 
   if (err.error) {
     const { message, error } = err
@@ -232,7 +193,7 @@ Connection.prototype._onError = function (err) {
 }
 
 Connection.prototype._onClose = function () {
-  this._reset()
+  this._recvMessages()
 
   if (this._deliberateClose === true) {
     this._setState(C.CONNECTION_STATE.CLOSED)
@@ -291,11 +252,6 @@ Connection.prototype._recvMessages = function (deadline) {
   this._schedule(this._recvMessages)
 }
 
-Connection.prototype._reset = function () {
-  this._recvQueue = new FixedQueue()
-  this._sendQueue = new FixedQueue()
-}
-
 Connection.prototype._handleConnectionResponse = function (message) {
   if (message.action === C.ACTIONS.PING) {
     this._submit(messageBuilder.getMsg(C.TOPIC.CONNECTION, C.ACTIONS.PONG))
@@ -363,7 +319,6 @@ Connection.prototype._setState = function (state) {
     this._client.emit(C.EVENT.CONNECTED, true)
   } else if (state === C.CONNECTION_STATE.RECONNECTING || state === C.CONNECTION_STATE.CLOSED) {
     this._client.emit(C.EVENT.CONNECTED, false)
-    this._reset()
   }
 }
 

package/src/record/record-handler.js

@@ -162,10 +162,7 @@ class RecordHandler {
 
         const token = xuid()
         this._syncEmitter.once(token, resolve)
-
-        if (this._connected) {
-          this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, [token])
-        }
+        this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, [token])
       }
 
       for (const rec of this._pending) {

package/src/record/record.js

@@ -22,11 +22,9 @@ class Record {
     this._updating = null
     this._patching = null
     this._pending = false
-    this._subscribed = false
+    this._subscribed = this._sendMsg1(C.ACTIONS.SUBSCRIBE, this._name)
 
     this._onPending(true)
-
-    this._subscribe()
   }
 
   get name() {
@@ -56,7 +54,7 @@ class Record {
     }
 
     if (!this._subscribed) {
-      this._subscribe()
+      this._subscribed = this._sendMsg1(C.ACTIONS.SUBSCRIBE, this._name)
     }
 
     return this
@@ -235,13 +233,11 @@ class Record {
 
   _$onConnectionStateChange(connected) {
     if (connected) {
-      if (this._refs > 0) {
-        this._subscribe()
-      }
+      this._subscribed = this._refs > 0 && this._sendMsg1(C.ACTIONS.SUBSCRIBE, this._name)
 
       if (this._updating) {
         for (const update of this._updating.values()) {
-          this._handler._connection.connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, update)
+          this._sendMsg1(C.ACTIONS.UPDATE, update)
         }
       }
     } else {
@@ -258,29 +254,14 @@ class Record {
     }
   }
 
-  _subscribe() {
-    if (!this._handler._connection.connected) {
-      return
-    }
-
-    invariant(this._handler._connection.connected, 'must be connected')
-
-    this._handler._connection.sendMsg1(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, this._name)
-    this._subscribed = true
-  }
-
   _$dispose() {
     invariant(!this._refs, 'must not have refs')
     invariant(!this._patching, 'must not have patches')
     invariant(!this._updating, 'must not have updates')
     invariant(!this._pending, 'must not be pending')
-    invariant(
-      !this._subscribed || this._handler._connection.connected,
-      'must be unsubscribed or connected'
-    )
 
     if (this._subscribed) {
-      this._handler._connection.sendMsg1(C.TOPIC.RECORD, C.ACTIONS.UNSUBSCRIBE, this._name)
+      this._sendMsg1(C.ACTIONS.UNSUBSCRIBE, this._name)
       this._subscribed = false
     }
 
@@ -293,6 +274,8 @@ class Record {
   _update(nextData) {
     invariant(this._version, 'must have version')
 
+    const connection = this._handler._connection
+
     if (nextData === this._data) {
       return
     }
@@ -310,10 +293,7 @@ class Record {
     this._updating.set(nextVersion, update)
     this._handler._stats.updating += 1
 
-    const connection = this._handler._connection
-    if (connection.connected) {
-      connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, update)
-    }
+    connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, update)
 
     this._data = nextData
     this._version = nextVersion
@@ -404,6 +384,10 @@ class Record {
     }
   }
 
+  _sendMsg1(action, data) {
+    return this._handler._connection.sendMsg1(C.TOPIC.RECORD, action, data)
+  }
+
   _error(event, msgOrError, data) {
     this._handler._client._$onError(C.TOPIC.RECORD, event, msgOrError, [
       ...(Array.isArray(data) ? data : []),