@nxtedition/deepstream.io-client-js 23.4.61 → 24.0.1

package/package.json

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

package/src/record/record-handler.js

@@ -13,6 +13,44 @@ const timers = require('../utils/timers')
 
 const kEmpty = Symbol('kEmpty')
 
+function onUpdate(record, subscription) {
+  if (subscription.state && record.state < subscription.state) {
+    return
+  }
+
+  if (subscription.timeout) {
+    timers.clearTimeout(subscription.timeout)
+    subscription.timeout = null
+  }
+
+  const data = subscription.path ? record.get(subscription.path) : record.data
+
+  if (subscription.dataOnly) {
+    if (data !== subscription.data) {
+      subscription.data = data
+      subscription.subscriber.next(data)
+    }
+  } else {
+    subscription.subscriber.next({
+      name: record.name,
+      version: record.version,
+      state: record.state,
+      data,
+    })
+  }
+}
+
+function onTimeout(subscription) {
+  const expected = C.RECORD_STATE_NAME[subscription.state]
+  const current = C.RECORD_STATE_NAME[subscription.record.state]
+
+  subscription.subscriber.error(
+    Object.assign(new Error(`timeout  ${subscription.record.name} [${current}<${expected}]`), {
+      code: 'ETIMEDOUT',
+    })
+  )
+}
+
 class RecordHandler {
   constructor(options, connection, client) {
     this.JSON = jsonPath
@@ -132,6 +170,10 @@ class RecordHandler {
     return this._stats
   }
 
+  /**
+   * @param {string} name
+   * @returns {Record}
+   */
   getRecord(name) {
     invariant(
       typeof name === 'string' && name.length > 0 && name !== '[object Object]',
@@ -261,7 +303,7 @@ class RecordHandler {
     let path
     let state = defaults ? defaults.state : undefined
     let signal
-    let timeoutValue = defaults ? defaults.timeout : undefined
+    let timeout = defaults ? defaults.timeout : undefined
     let dataOnly = defaults ? defaults.dataOnly : undefined
 
     let idx = 0
@@ -282,7 +324,7 @@ class RecordHandler {
       }
 
       if (options.timeout != null) {
-        timeoutValue = options.timeout
+        timeout = options.timeout
       }
 
       if (options.path != null) {
@@ -302,84 +344,53 @@ class RecordHandler {
       state = C.RECORD_STATE[state.toUpperCase()]
     }
 
-    if (!name) {
-      const data = path ? undefined : jsonPath.EMPTY
-      return rxjs.of(
-        dataOnly
-          ? data
-          : utils.deepFreeze({
-              name,
-              version: '0-00000000000000',
-              data,
-              state: Number.isFinite(state) ? state : C.RECORD_STATE.SERVER,
-            })
-      )
-    }
-
-    if (signal?.aborted) {
-      return rxjs.throwError(() => new utils.AbortError())
-    }
-
-    return new rxjs.Observable((o) => {
-      let timeoutHandle
-      let prevData = kEmpty
-
-      const onUpdate = (record) => {
-        if (state && record.state < state) {
-          return
-        }
-
-        if (timeoutHandle) {
-          timers.clearTimeout(timeoutHandle)
-          timeoutHandle = null
-        }
+    return new rxjs.Observable((subscriber) => {
+      const subscription = {
+        subscriber,
+        path,
+        state,
+        signal,
+        dataOnly,
+        data: kEmpty,
+        timeout: null,
+        /** @type {Record?} */ record: null,
+        /** @type {Function?} */ abort: null,
+        unsubscribe() {
+          if (this.timeout) {
+            timers.clearTimeout(this.timeout)
+            this.timeout = null
+          }
 
-        const nextData = path ? record.get(path) : record.data
+          if (this.signal) {
+            utils.removeAbortListener(this.signal, this.abort)
+            this.signal = null
+            this.abort = null
+          }
 
-        if (dataOnly) {
-          if (nextData !== prevData) {
-            prevData = nextData
-            o.next(nextData)
+          if (this.record) {
+            this.record.unsubscribe(onUpdate, this)
+            this.record.unref()
+            this.record = null
           }
-        } else {
-          o.next({
-            name: record.name,
-            version: record.version,
-            data: nextData,
-            state: record.state,
-          })
-        }
+        },
       }
 
-      const record = this.getRecord(name).subscribe(onUpdate)
-
-      if (timeoutValue && state && record.state < state) {
-        timeoutHandle = timers.setTimeout(() => {
-          const expected = C.RECORD_STATE_NAME[state]
-          const current = C.RECORD_STATE_NAME[record.state]
-          o.error(
-            Object.assign(
-              new Error(
-                `timeout after ${timeoutValue / 1e3}s: ${record.name} [${current}<${expected}]`
-              ),
-              { code: 'ETIMEDOUT' }
-            )
-          )
-        }, timeoutValue)
-      }
+      subscription.record = this.getRecord(name).subscribe(onUpdate, subscription)
 
-      if (record.version) {
-        onUpdate(record)
+      if (timeout && subscription.state && subscription.record.state < subscription.state) {
+        subscription.timeout = timers.setTimeout(onTimeout, timeout, subscription)
       }
 
-      const abort = signal ? () => o.error(new utils.AbortError()) : null
-
-      utils.addAbortListener(signal, abort)
+      if (subscription.record.version) {
+        onUpdate(subscription.record, subscription)
+      }
 
-      return () => {
-        record.unsubscribe(onUpdate).unref()
-        utils.removeAbortListener(signal, abort)
+      if (subscription.signal) {
+        subscription.abort = () => subscription.subscriber.error(new utils.AbortError())
+        utils.addAbortListener(subscription.signal, subscription.abort)
       }
+
+      return subscription
     })
   }
 

package/src/record/record.js

@@ -47,6 +47,10 @@ class Record {
     return this._refs
   }
 
+  /**
+   *
+   * @returns {Record}
+   */
   ref() {
     this._refs += 1
     if (this._refs === 1) {
@@ -56,6 +60,10 @@ class Record {
     return this
   }
 
+  /**
+   *
+   * @returns {Record}
+   */
   unref() {
     this._refs -= 1
     if (this._refs === 0) {
@@ -64,26 +72,48 @@ class Record {
     return this
   }
 
-  subscribe(fn) {
+  /**
+   *
+   * @param {*} fn
+   * @param {*} opaque
+   * @returns {Record}
+   */
+  subscribe(fn, opaque = null) {
     if (this._emitting) {
       this._subscriptions = this._subscriptions.slice()
       this._emitting = false
     }
 
-    this._subscriptions.push(fn)
+    this._subscriptions.push(fn, opaque)
 
     return this
   }
 
-  unsubscribe(fn) {
+  /**
+   *
+   * @param {*} fn
+   * @param {*} opaque
+   * @returns {Record}
+   */
+  unsubscribe(fn, opaque = null) {
     if (this._emitting) {
       this._subscriptions = this._subscriptions.slice()
       this._emitting = false
     }
 
-    const idx = this._subscriptions.indexOf(fn)
+    let idx = -1
+
+    const arr = this._subscriptions
+    const len = arr.length
+    for (let n = 0; n < len; n += 2) {
+      if (arr[n + 0] === fn && arr[n + 1] === opaque) {
+        idx = n
+        break
+      }
+    }
+
     if (idx !== -1) {
-      this._subscriptions.splice(idx, 1)
+      this._subscriptions.splice(idx, 2)
     }
 
     return this
@@ -417,9 +447,12 @@ class Record {
   _emitUpdate() {
     this._emitting = true
     try {
-      for (const fn of this._subscriptions) {
+      const arr = this._subscriptions
+      const len = arr.length
+
+      for (let n = 0; n < len; n += 2) {
         try {
-          fn(this)
+          arr[n + 0](this, arr[n + 1])
         } catch (err) {
           this._error(
             C.EVENT.USER_ERROR,

package/src/utils/utils.js

@@ -143,13 +143,17 @@ module.exports.addAbortListener = function addAbortListener(signal, handler) {
     return
   }
 
-  let handlers = abortSignals.get(signal)
-  if (!handlers) {
-    handlers = []
-    abortSignals.set(signal, handlers)
-    signal.addEventListener('abort', onAbort)
+  if (signal.aborted) {
+    queueMicrotask(handler)
+  } else {
+    let handlers = abortSignals.get(signal)
+    if (!handlers) {
+      handlers = []
+      abortSignals.set(signal, handlers)
+      signal.addEventListener('abort', onAbort)
+    }
+    handlers.push(handler)
   }
-  handlers.push(handler)
 }
 
 module.exports.removeAbortListener = function removeAbortListener(signal, handler) {