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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "23.4.52",
+  "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

@@ -16,12 +16,15 @@ class Record {
     this._version = ''
     this._data = jsonPath.EMPTY
     this._state = Record.STATE.VOID
-    this._refs = 0
+    this._refs = 1
     this._subscriptions = []
-    this._subscriptionsEmitting = false
+    this._emitting = false
     this._updating = null
-    this._patches = null
-    this._subscribed = false
+    this._patching = null
+    this._pending = false
+    this._subscribed = this._sendMsg1(C.ACTIONS.SUBSCRIBE, this._name)
+
+    this._onPending(true)
   }
 
   get name() {
@@ -50,8 +53,8 @@ class Record {
       this._handler._onPruning(this, false)
     }
 
-    if (this._refs === 1 && this._handler._connection.connected && !this._subscribed) {
-      this._subscribe()
+    if (!this._subscribed) {
+      this._subscribed = this._sendMsg1(C.ACTIONS.SUBSCRIBE, this._name)
     }
 
     return this
@@ -59,7 +62,7 @@ class Record {
 
   unref() {
     invariant(this._refs > 0, 'missing refs')
-    invariant(this._refs > 0 || !this._patches, 'must not have patches')
+    invariant(this._refs > 0 || !this._patching, 'must not have patches')
     invariant(this._refs > 0 || this._state >= Record.STATE.SERVER, 'must be ready')
 
     this._refs -= 1
@@ -71,9 +74,9 @@ class Record {
   }
 
   subscribe(fn) {
-    if (this._subscriptionsEmitting) {
+    if (this._emitting) {
       this._subscriptions = this._subscriptions.slice()
-      this._subscriptionsEmitting = false
+      this._emitting = false
     }
 
     this._subscriptions.push(fn)
@@ -82,9 +85,9 @@ class Record {
   }
 
   unsubscribe(fn) {
-    if (this._subscriptionsEmitting) {
+    if (this._emitting) {
       this._subscriptions = this._subscriptions.slice()
-      this._subscriptionsEmitting = false
+      this._emitting = false
     }
 
     const idx = this._subscriptions.indexOf(fn)
@@ -128,14 +131,14 @@ class Record {
     }
 
     if (this._state < Record.STATE.SERVER) {
-      if (!this._patches) {
+      if (!this._patching) {
         this.ref()
-        this._patches = []
+        this._patching = []
       } else if (path) {
-        this._patches.splice(0)
+        this._patching.splice(0)
       }
 
-      this._patches.push(path, cloneDeep(data))
+      this._patching.push(path, cloneDeep(data))
     } else {
       this._update(jsonPath.set(this._data, path, data, false))
     }
@@ -228,49 +231,37 @@ class Record {
     return true
   }
 
-  _$onConnectionStateChange() {
-    if (this._handler._connection.connected) {
-      if (this._refs > 0) {
-        this._subscribe()
-      }
+  _$onConnectionStateChange(connected) {
+    if (connected) {
+      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 {
       this._subscribed = false
     }
 
+    if (!this._pending) {
+      this._onPending(true)
+    }
+
     if (this._state > Record.STATE.CLIENT) {
       this._state = Record.STATE.CLIENT
       this._emitUpdate()
     }
   }
 
-  _subscribe() {
-    invariant(this._handler._connection.connected, 'must be connected')
-
-    this._handler._connection.sendMsg1(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, this._name)
-    this._subscribed = true
-
-    this.ref()
-    this._handler._onPending(this, true)
-  }
-
   _$dispose() {
     invariant(!this._refs, 'must not have refs')
-    invariant(!this._patches, 'must not have patches')
+    invariant(!this._patching, 'must not have patches')
     invariant(!this._updating, 'must not have updates')
-    invariant(this.state >= C.RECORD_STATE.SERVER, 'must not be pending')
-    invariant(
-      !this._subscribed || this._handler._connection.connected,
-      'must be unsubscribed or connected'
-    )
+    invariant(!this._pending, 'must not be pending')
 
     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
     }
 
@@ -283,6 +274,8 @@ class Record {
   _update(nextData) {
     invariant(this._version, 'must have version')
 
+    const connection = this._handler._connection
+
     if (nextData === this._data) {
       return
     }
@@ -300,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
@@ -334,23 +324,25 @@ class Record {
     invariant(this._version, 'must have version')
     invariant(this._data, 'must have data')
 
-    if (this._patches) {
+    if (this._patching) {
       if (this._version.charAt(0) !== 'I') {
         let patchData = this._data
-        for (let n = 0; n < this._patches.length; n += 2) {
-          patchData = jsonPath.set(patchData, this._patches[n + 0], this._patches[n + 1], false)
+        for (let n = 0; n < this._patching.length; n += 2) {
+          patchData = jsonPath.set(patchData, this._patching[n + 0], this._patching[n + 1], false)
         }
         this._update(patchData)
       }
 
-      this._patches = null
+      this._patching = null
       this.unref()
     }
 
     if (this._state < C.RECORD_STATE.SERVER) {
       this._state = this._version.charAt(0) === 'I' ? C.RECORD_STATE.STALE : C.RECORD_STATE.SERVER
-      this._handler._onPending(this, false)
-      this.unref()
+    }
+
+    if (this._pending) {
+      this._onPending(false)
     }
 
     if (this._state !== prevState || this._data !== prevData || this._version !== prevVersion) {
@@ -358,13 +350,30 @@ class Record {
     }
   }
 
+  _onPending(value) {
+    if (this._pending === value) {
+      return
+    }
+
+    this._pending = value
+    this._handler._onPending(this, value)
+
+    if (value) {
+      this.ref()
+    } else {
+      this.unref()
+    }
+  }
+
   _onSubscriptionHasProvider([, hasProvider]) {
+    if (this._state < C.RECORD_STATE.SERVER) {
+      return
+    }
+
     const prevState = this._state
 
     this._state =
-      hasProvider &&
-      messageParser.convertTyped(hasProvider, this._handler._client) &&
-      this._state >= C.RECORD_STATE.SERVER
+      hasProvider && messageParser.convertTyped(hasProvider, this._handler._client)
         ? C.RECORD_STATE.PROVIDER
         : this._version.charAt(0) === 'I'
         ? C.RECORD_STATE.STALE
@@ -375,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 : []),
@@ -394,7 +407,7 @@ class Record {
   }
 
   _emitUpdate() {
-    this._subscriptionsEmitting = true
+    this._emitting = true
     try {
       for (const fn of this._subscriptions) {
         try {
@@ -407,7 +420,7 @@ class Record {
         }
       }
     } finally {
-      this._subscriptionsEmitting = false
+      this._emitting = false
     }
   }
 }