@nxtedition/deepstream.io-client-js 23.4.48 → 23.4.50

package/package.json

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

package/src/constants/constants.js

@@ -10,13 +10,11 @@ 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
-module.exports.RECORD_STATE.SERVER = 3
-module.exports.RECORD_STATE.STALE = 4
-module.exports.RECORD_STATE.PROVIDER = 5
+module.exports.RECORD_STATE.SERVER = 2
+module.exports.RECORD_STATE.STALE = 3
+module.exports.RECORD_STATE.PROVIDER = 4
 
 module.exports.RECORD_STATE_NAME = []
 for (const [key, val] of Object.entries(module.exports.RECORD_STATE)) {

package/src/record/record-handler.js

@@ -35,6 +35,7 @@ class RecordHandler {
     }
 
     this._syncEmitter = new EventEmitter()
+    this._pendingEmitter = new EventEmitter()
 
     this.set = this.set.bind(this)
     this.get = this.get.bind(this)
@@ -49,52 +50,41 @@ class RecordHandler {
 
     this._pruningTimeout = null
 
-    // TODO (perf): schedule & yield to avoid blocking event loop?
     const _prune = () => {
       const pruning = this._pruning
-
       this._pruning = new Set()
-      for (const rec of pruning) {
-        invariant(rec.refs === 0, 'cannot prune referenced record')
-        invariant(!this._pending.has(rec), 'cannot prune pending record')
 
+      for (const rec of pruning) {
         rec._$dispose()
         this._records.delete(rec.name)
         this._stats.destroyed++
       }
 
-      if (this._pruningTimeout && this._pruningTimeout.refresh) {
+      if (this._pruningTimeout) {
         this._pruningTimeout.refresh()
       } else {
-        this._pruningTimeout = setTimeout(_prune, 1e3)
-        if (this._pruningTimeout.unref) {
-          this._pruningTimeout.unref()
-        }
+        this._pruningTimeout = timers.setTimeout(_prune, 1e3)
       }
     }
 
     _prune()
   }
 
-  _onRef(rec) {
-    if (rec.refs === 0) {
+  _onPruning(rec, isPruning) {
+    if (isPruning) {
       this._pruning.add(rec)
-    } else if (rec.refs === 1) {
+    } else {
       this._pruning.delete(rec)
     }
   }
 
-  _onState(rec, prevState) {
-    if (
-      rec.state < Record.STATE.SERVER &&
-      (prevState === Record.STATE.INIT || prevState >= Record.STATE.SERVER)
-    ) {
-      rec.ref()
+  _onPending(rec, isPending) {
+    if (isPending) {
       this._pending.add(rec)
-    } else if (prevState >= Record.STATE.SERVER) {
-      rec.unref()
+    } else {
       this._pending.delete(rec)
     }
+    this._pendingEmitter.emit(rec.name, isPending)
   }
 
   get connected() {
@@ -120,7 +110,7 @@ class RecordHandler {
     let record = this._records.get(name)
 
     if (!record) {
-      record = new Record(name, this)
+      record = new Record(name, this).ref()
       this._records.set(name, record)
       this._stats.created++
     } else {
@@ -163,7 +153,7 @@ class RecordHandler {
 
   sync() {
     return new Promise((resolve) => {
-      let counter = 0
+      let counter = this._pending.size
 
       const maybeSync = () => {
         if (counter > 0) {
@@ -178,24 +168,12 @@ class RecordHandler {
         }
       }
 
-      const onUpdate = (rec) => {
-        if (rec.state < C.RECORD_STATE.SERVER) {
-          return
-        }
-
-        rec.unsubscribe(onUpdate)
-        rec.unref()
-        counter -= 1
-
-        maybeSync()
-      }
-
       for (const rec of this._pending) {
-        if (rec.state < C.RECORD_STATE.SERVER) {
-          rec.subscribe(onUpdate)
-          rec.ref()
-          counter += 1
-        }
+        this._pendingEmitter.once(rec.name, (isPending) => {
+          invariant(!isPending, 'unexpected pending state')
+          counter -= 1
+          maybeSync()
+        })
       }
 
       maybeSync()
@@ -347,7 +325,7 @@ class RecordHandler {
       const record = this.getRecord(name).subscribe(onUpdate)
 
       if (timeoutValue && state && record.state < state) {
-        timeoutHandle = timers.setTimeout(() => {
+        timeoutHandle = timers.timers.setTimeout(() => {
           const expected = C.RECORD_STATE_NAME[state]
           const current = C.RECORD_STATE_NAME[record.state]
           o.error(

package/src/record/record.js

@@ -16,16 +16,12 @@ class Record {
     this._version = ''
     this._data = jsonPath.EMPTY
     this._state = Record.STATE.VOID
-    this._refs = 1
-    this._subscribed = false
+    this._refs = 0
     this._subscriptions = []
     this._subscriptionsEmitting = false
     this._updating = null
     this._patches = null
-
-    this._handler._onState(this, Record.STATE.INIT)
-
-    this._subscribe()
+    this._subscribed = false
   }
 
   get name() {
@@ -49,26 +45,27 @@ class Record {
   }
 
   ref() {
-    const prevRefs = this._refs
-
     this._refs += 1
-    if (this._refs === 1 && !this._subscribed) {
-      this._subscribe()
+    if (this._refs === 1) {
+      this._handler._onPruning(this, false)
     }
 
-    this._handler._onRef(this, prevRefs)
+    if (this._refs === 1 && this._handler._connection.connected && !this._subscribed) {
+      this._subscribe()
+    }
 
     return this
   }
 
   unref() {
     invariant(this._refs > 0, 'missing refs')
-
-    const prevRefs = this._refs
+    invariant(this._refs > 1 || !this._patches, 'must not have patches')
+    invariant(this._refs > 1 || this._state >= Record.STATE.SERVER, 'must be ready')
 
     this._refs -= 1
-
-    this._handler._onRef(this, prevRefs)
+    if (this._refs === 0) {
+      this._handler._onPruning(this, true)
+    }
 
     return this
   }
@@ -103,7 +100,6 @@ class Record {
   }
 
   set(pathOrData, dataOrNil) {
-    const prevState = this._state
     const prevData = this._data
     const prevVersion = this._version
 
@@ -131,15 +127,20 @@ class Record {
       throw new Error('invalid argument: path')
     }
 
-    this._update(jsonPath.set(this._data, path, data, false))
-
     if (this._state < Record.STATE.SERVER) {
-      this._patches = path && this._patches ? this._patches : []
+      if (!this._patches) {
+        this.ref()
+        this._patches = []
+      } else if (path) {
+        this._patches.splice(0)
+      }
+
       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) {
+    } else {
+      this._update(jsonPath.set(this._data, path, data, false))
+    }
+
+    if (this._data !== prevData || this._version !== prevVersion) {
       this._emitUpdate()
     }
   }
@@ -228,93 +229,97 @@ class Record {
   }
 
   _$onConnectionStateChange() {
-    const connection = this._handler._connection
-    if (connection.connected) {
-      invariant(!this._subscribed, 'must not be subscribed')
-
+    if (this._handler._connection.connected) {
       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)
+          this._handler._connection.connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, update)
         }
       }
     } else {
-      this._unsubscribe()
+      this._subscribed = false
     }
-  }
 
-  _$dispose() {
-    this._unsubscribe()
+    if (this._state > Record.STATE.CLIENT) {
+      this._state = Record.STATE.CLIENT
+      this._emitUpdate()
+    }
   }
 
   _subscribe() {
-    const connection = this._handler._connection
+    invariant(this._handler._connection.connected, 'must be connected')
 
-    invariant(this._refs, 'missing refs')
-    invariant(!this._subscribed, 'must not be subscribed')
+    this._handler._connection.sendMsg1(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, this._name)
+    this._subscribed = true
 
-    if (!this._subscribed && connection.connected) {
-      connection.sendMsg1(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, this._name)
-      this._subscribed = true
-    }
+    this.ref()
+    this._handler._onPending(this, true)
   }
 
-  _unsubscribe() {
-    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)
+  _$dispose() {
+    invariant(!this._refs, 'must not have refs')
+    invariant(!this._patches, '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'
+    )
+
+    if (this._subscribed) {
+      this._handler._connection.sendMsg1(C.TOPIC.RECORD, C.ACTIONS.UNSUBSCRIBE, this._name)
       this._subscribed = false
     }
 
-    if (this._state > Record.STATE.CLIENT) {
-      this._state = Record.STATE.CLIENT
-      this._handler._onState(this, prevState)
+    if (this._state > C.RECORD_STATE.CLIENT) {
+      this._state = C.RECORD_STATE.CLIENT
       this._emitUpdate()
     }
   }
 
   _update(nextData) {
+    invariant(this._version, 'must have version')
+
     if (nextData === this._data) {
-      return false
+      return
     }
 
-    this._data = nextData
+    const prevVersion = this._version
+    const nextVersion = this._makeVersion(parseInt(prevVersion) + 1)
 
-    if (this._version) {
-      const prevVersion = this._version
-      const nextVersion = this._makeVersion(parseInt(prevVersion) + 1)
-      this._version = nextVersion
+    const update = [this._name, nextVersion, jsonPath.stringify(nextData), prevVersion]
 
-      const update = [this._name, nextVersion, jsonPath.stringify(nextData), prevVersion]
-      this._updating ??= new Map()
-      this._updating.set(nextVersion, update)
-      this._handler._stats.updating += 1
+    if (!this._updating) {
+      this._updating = new Map()
+      this.ref()
+    }
 
-      const connection = this._handler._connection
-      if (connection.connected) {
-        connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, update)
-      }
+    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)
     }
 
-    return true
+    this._data = nextData
+    this._version = nextVersion
   }
 
   _onUpdate([, version, data]) {
-    const prevState = this._state
     const prevData = this._data
     const prevVersion = this._version
+    const prevState = this._state
 
     if (this._updating?.delete(version)) {
       this._handler._stats.updating -= 1
+      if (this._updating.size === 0) {
+        this._updating = null
+        this.unref()
+      }
     }
 
     if (
@@ -329,20 +334,26 @@ class Record {
     invariant(this._version, 'must have version')
     invariant(this._data, 'must have data')
 
-    if (this._patches && 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)
+    if (this._patches) {
+      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)
+        }
+        this._update(patchData)
       }
-      this._update(patchData)
+
+      this._patches = null
+      this.unref()
     }
-    this._patches = null
 
-    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) {
+    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._state !== prevState || this._data !== prevData || this._version !== prevVersion) {
       this._emitUpdate()
     }
   }
@@ -353,14 +364,13 @@ class Record {
     this._state =
       hasProvider &&
       messageParser.convertTyped(hasProvider, this._handler._client) &&
-      this._state >= Record.STATE.SERVER
-        ? Record.STATE.PROVIDER
+      this._state >= C.RECORD_STATE.SERVER
+        ? C.RECORD_STATE.PROVIDER
         : this._version.charAt(0) === 'I'
-        ? Record.STATE.STALE
-        : Record.STATE.SERVER
+        ? C.RECORD_STATE.STALE
+        : C.RECORD_STATE.SERVER
 
     if (this._state !== prevState) {
-      this._handler._onState(this, prevState)
       this._emitUpdate()
     }
   }
@@ -387,7 +397,14 @@ class Record {
     this._subscriptionsEmitting = true
     try {
       for (const fn of this._subscriptions) {
-        fn(this)
+        try {
+          fn(this)
+        } catch (err) {
+          this._error(
+            C.EVENT.USER_ERROR,
+            Object.assign(new Error('user callback failed'), { cause: err })
+          )
+        }
       }
     } finally {
       this._subscriptionsEmitting = false