@nxtedition/deepstream.io-client-js 23.4.46 → 23.4.47

package/package.json

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

package/src/constants/constants.js

@@ -10,6 +10,7 @@ module.exports.CONNECTION_STATE.ERROR = 'ERROR'
 module.exports.CONNECTION_STATE.RECONNECTING = 'RECONNECTING'
 
 module.exports.RECORD_STATE = {}
+module.exports.RECORD_STATE.INIT = -1
 module.exports.RECORD_STATE.VOID = 0
 module.exports.RECORD_STATE.CLIENT = 1
 module.exports.RECORD_STATE.PENDING = 2

package/src/message/connection.js

@@ -363,6 +363,7 @@ 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

@@ -76,26 +76,20 @@ class RecordHandler {
     _prune()
   }
 
-  _onRef(rec, prevRefs) {
-    const curr = rec.refs === 0
-    const prev = prevRefs === 0
-
-    if (curr && !prev) {
+  _onRef(rec) {
+    if (rec.refs === 0) {
       this._pruning.add(rec)
-    } else if (!curr && prev) {
+    } else if (rec.refs === 1) {
       this._pruning.delete(rec)
     }
   }
 
   _onState(rec, prevState) {
-    const curr = rec.state < C.RECORD_STATE.SERVER
-    const prev = prevState < C.RECORD_STATE.SERVER
-
-    if (curr && !prev) {
+    // TODO (perf): avoid pending.has
+    if (rec.state < Record.STATE.SERVER && !this._pending.has(rec)) {
       this._pending.add(rec)
       rec.ref()
-    } else if (!curr && prev) {
-      this._pending.delete(rec)
+    } else if (this._pending.delete(rec)) {
       rec.unref()
     }
   }
@@ -181,11 +175,15 @@ class RecordHandler {
         }
       }
 
+      const xs = new Set()
+
       const onUpdate = (rec) => {
         if (rec.state < C.RECORD_STATE.SERVER) {
           return
         }
 
+        xs.delete(rec.name)
+
         rec.unsubscribe(onUpdate)
         rec.unref()
         counter -= 1
@@ -195,8 +193,9 @@ class RecordHandler {
 
       for (const rec of this._pending) {
         if (rec.state < C.RECORD_STATE.SERVER) {
-          rec.ref()
+          xs.add(rec.name)
           rec.subscribe(onUpdate)
+          rec.ref()
           counter += 1
         }
       }

package/src/record/record.js

@@ -23,7 +23,9 @@ class Record {
     this._updating = null
     this._patches = null
 
-    this._mutate(() => this._subscribe())
+    this._handler._onState(this, Record.STATE.INIT)
+
+    this._subscribe()
   }
 
   get name() {
@@ -50,8 +52,8 @@ class Record {
     const prevRefs = this._refs
 
     this._refs += 1
-    if (this._refs === 1) {
-      this._mutate(() => this._subscribe())
+    if (this._refs === 1 && !this._subscribed) {
+      this._subscribe()
     }
 
     this._handler._onRef(this, prevRefs)
@@ -60,7 +62,7 @@ class Record {
   }
 
   unref() {
-    invariant(this._refs > 0, this._name + ' missing refs')
+    invariant(this._refs > 0, 'missing refs')
 
     const prevRefs = this._refs
 
@@ -101,44 +103,50 @@ class Record {
   }
 
   set(pathOrData, dataOrNil) {
-    return this._mutate(() => {
-      invariant(this._refs > 0, this._name + ' missing refs')
+    const prevState = this._state
+    const prevData = this._data
+    const prevVersion = this._version
 
-      if (this._version.charAt(0) === 'I' || this._name.startsWith('_')) {
-        this._error(C.EVENT.USER_ERROR, 'cannot set')
-        return
-      }
+    invariant(this._refs > 0, 'missing refs')
 
-      const path = arguments.length === 1 ? undefined : pathOrData
-      const data = arguments.length === 1 ? pathOrData : dataOrNil
+    if (this._version.charAt(0) === 'I' || this._name.startsWith('_')) {
+      this._error(C.EVENT.USER_ERROR, 'cannot set')
+      return
+    }
 
-      if (path === undefined && !utils.isPlainObject(data)) {
-        throw new Error('invalid argument: data')
-      }
-      if (path === undefined && Object.keys(data).some((prop) => prop.startsWith('_'))) {
-        throw new Error('invalid argument: data')
-      }
-      if (
-        path !== undefined &&
-        (typeof path !== 'string' || path.length === 0 || path.startsWith('_')) &&
-        (!Array.isArray(path) || path.length === 0 || path[0].startsWith('_'))
-      ) {
-        throw new Error('invalid argument: path')
-      }
+    const path = arguments.length === 1 ? undefined : pathOrData
+    const data = arguments.length === 1 ? pathOrData : dataOrNil
 
-      if (this._state < Record.STATE.SERVER) {
-        this._patches = path && this._patches ? this._patches : []
-        this._patches.push(path, cloneDeep(data))
-        this._state = Record.STATE.PENDING
-      }
+    if (path === undefined && !utils.isPlainObject(data)) {
+      throw new Error('invalid argument: data')
+    }
+    if (path === undefined && Object.keys(data).some((prop) => prop.startsWith('_'))) {
+      throw new Error('invalid argument: data')
+    }
+    if (
+      path !== undefined &&
+      (typeof path !== 'string' || path.length === 0 || path.startsWith('_')) &&
+      (!Array.isArray(path) || path.length === 0 || path[0].startsWith('_'))
+    ) {
+      throw new Error('invalid argument: path')
+    }
 
-      this._update(jsonPath.set(this._data, path, data, false))
-    })
+    this._update(jsonPath.set(this._data, path, data, false))
+
+    if (this._state < Record.STATE.SERVER) {
+      this._patches = path && this._patches ? this._patches : []
+      this._patches.push(path, cloneDeep(data))
+      this._state = Record.STATE.PENDING
+      this._handler._onState(this, prevState)
+      this._emitUpdate()
+    } else if (this._data !== prevData || this._version !== prevVersion) {
+      this._emitUpdate()
+    }
   }
 
   // TODO (fix): timeout + signal
   when(stateOrNull) {
-    invariant(this._refs > 0, this._name + ' missing refs')
+    invariant(this._refs > 0, 'missing refs')
 
     const state = stateOrNull == null ? Record.STATE.SERVER : stateOrNull
 
@@ -169,7 +177,7 @@ class Record {
   }
 
   update(pathOrUpdater, updaterOrNil) {
-    invariant(this._refs > 0, this._name + ' missing refs')
+    invariant(this._refs > 0, 'missing refs')
 
     if (this._version.charAt(0) === 'I') {
       this._handler._client._$onError(C.TOPIC.RECORD, C.EVENT.UPDATE_ERROR, 'cannot update', [
@@ -209,9 +217,9 @@ class Record {
 
   _$onMessage(message) {
     if (message.action === C.ACTIONS.UPDATE) {
-      this._mutate(() => this._onUpdate(message.data))
+      this._onUpdate(message.data)
     } else if (message.action === C.ACTIONS.SUBSCRIPTION_HAS_PROVIDER) {
-      this._mutate(() => this._onSubscriptionHasProvider(message.data))
+      this._onSubscriptionHasProvider(message.data)
     } else {
       return false
     }
@@ -220,35 +228,34 @@ class Record {
   }
 
   _$onConnectionStateChange() {
-    return this._mutate(() => {
-      const connection = this._handler._connection
-      if (connection.connected) {
-        if (this._refs > 0) {
-          this._subscribe()
-        }
+    const connection = this._handler._connection
+    if (connection.connected) {
+      invariant(!this._subscribed, 'must not be subscribed')
 
-        if (this._updating) {
-          for (const update of this._updating.values()) {
-            connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, update)
-          }
-        }
-      } else {
-        this._subscribed = false
-        if (this._state > Record.STATE.CLIENT) {
-          this._state = Record.STATE.CLIENT
+      if (this._refs > 0) {
+        this._subscribe()
+      }
+
+      if (this._updating) {
+        for (const update of this._updating.values()) {
+          connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, update)
         }
       }
-    })
+    } else {
+      this._unsubscribe()
+    }
   }
 
   _$dispose() {
-    this._mutate(() => this._unsubscribe())
+    this._unsubscribe()
   }
 
   _subscribe() {
-    invariant(this._refs, this._name + ' missing refs')
-
     const connection = this._handler._connection
+
+    invariant(this._refs, 'missing refs')
+    invariant(!this._subscribed, 'must not be subscribed')
+
     if (!this._subscribed && connection.connected) {
       connection.sendMsg1(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, this._name)
       this._subscribed = true
@@ -256,17 +263,22 @@ class Record {
   }
 
   _unsubscribe() {
-    invariant(!this._refs, this._name + ' must not have refs')
-    invariant(!this._patches, this._name + ' must not have patches')
-
+    const prevState = this._state
     const connection = this._handler._connection
+
+    invariant(!connection.connected || !this._refs, 'must not have refs')
+    invariant(!connection.connected || !this._patches, 'must not have patches')
+    invariant(!connection.connected || this._subscribed, 'must be subscribed')
+
     if (this._subscribed && connection.connected) {
       connection.sendMsg1(C.TOPIC.RECORD, C.ACTIONS.UNSUBSCRIBE, this._name)
+      this._subscribed = false
     }
 
-    this._subscribed = false
     if (this._state > Record.STATE.CLIENT) {
       this._state = Record.STATE.CLIENT
+      this._handler._onState(this, prevState)
+      this._emitUpdate()
     }
   }
 
@@ -297,6 +309,10 @@ class Record {
   }
 
   _onUpdate([, version, data]) {
+    const prevState = this._state
+    const prevData = this._data
+    const prevVersion = this._version
+
     if (this._updating?.delete(version)) {
       this._handler._stats.updating -= 1
     }
@@ -324,10 +340,16 @@ class Record {
 
     if (this._state < Record.STATE.SERVER) {
       this._state = this._version.charAt(0) === 'I' ? Record.STATE.STALE : Record.STATE.SERVER
+      this._handler._onState(this, prevState)
+      this._emitUpdate()
+    } else if (this._data !== prevData || this._version !== prevVersion) {
+      this._emitUpdate()
     }
   }
 
   _onSubscriptionHasProvider([, hasProvider]) {
+    const prevState = this._state
+
     this._state =
       hasProvider &&
       messageParser.convertTyped(hasProvider, this._handler._client) &&
@@ -336,6 +358,11 @@ class Record {
         : this._version.charAt(0) === 'I'
         ? Record.STATE.STALE
         : Record.STATE.SERVER
+
+    if (this._state !== prevState) {
+      this._handler._onState(this, prevState)
+      this._emitUpdate()
+    }
   }
 
   _error(event, msgOrError, data) {
@@ -356,30 +383,15 @@ class Record {
     return `${start}-${revid}`
   }
 
-  _mutate(fn) {
-    const prevState = this._state
-    const prevData = this._data
-    const prevVersion = this._version
-
-    const ret = fn()
-
-    if (this._state !== prevState || this._data !== prevData || this._version !== prevVersion) {
-      try {
-        this._subscriptionsEmitting = true
-
-        if (this._state !== prevState) {
-          this._handler.onState(this, prevState)
-        }
-
-        for (const fn of this._subscriptions) {
-          fn(this)
-        }
-      } finally {
-        this._subscriptionsEmitting = false
+  _emitUpdate() {
+    this._subscriptionsEmitting = true
+    try {
+      for (const fn of this._subscriptions) {
+        fn(this)
       }
+    } finally {
+      this._subscriptionsEmitting = false
     }
-
-    return ret
   }
 }