@nxtedition/deepstream.io-client-js 23.4.0 → 23.4.2

package/package.json

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

package/src/record/record-handler.js

@@ -48,7 +48,17 @@ class RecordHandler {
 
     this._client.on(C.EVENT.CONNECTED, this._onConnectionStateChange.bind(this))
 
+    const _prune = () => {
+      if (!this._pruning) {
+        this._pruning = true
+        this._schedule(prune)
+      }
+    }
+
     const prune = () => {
+      this._now = Date.now()
+      this._pruning = false
+
       let counter = 0
       for (const [rec, timestamp] of this._prune) {
         if (this._now - timestamp < 1e3) {
@@ -65,22 +75,13 @@ class RecordHandler {
         this._prune.delete(rec)
 
         if (counter++ > 1024) {
-          this._schedule(prune)
-          return
+          _prune()
         }
       }
-
-      this._pruning = false
     }
 
-    const pruneInterval = setInterval(() => {
-      this._now = Date.now()
-      if (!this._pruning) {
-        this._pruning = true
-        this._schedule(prune)
-      }
-    }, 1e3)
-    pruneInterval.unref?.()
+    this._pruneInterval = setInterval(_prune, 1e3)
+    this._pruneInterval.unref?.()
   }
 
   _onRef(rec) {
@@ -154,13 +155,19 @@ class RecordHandler {
   }
 
   sync(options) {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
+      const timeoutValue = options?.timeout ?? 2 * 60e3
+      const signal = options?.signal
+
+      if (signal?.aborted) {
+        reject(new utils.AbortError())
+        return
+      }
+
       let done = false
       let token
-      let timeout
+      let timeoutHandle
 
-      const timeoutValue = 2 * 60e3
-      const signal = options?.signal
       const records = [...this._patch]
 
       const onDone = (val) => {
@@ -172,9 +179,9 @@ class RecordHandler {
 
         signal?.removeEventListener('abort', onAbort)
 
-        if (timeout) {
-          clearTimeout(timeout)
-          timeout = null
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle)
+          timeoutHandle = null
         }
 
         if (token) {
@@ -200,8 +207,8 @@ class RecordHandler {
       const onTimeout = () => {
         const elapsed = Date.now() - this._connected
         if (elapsed < timeoutValue) {
-          timeout = setTimeout(onTimeout, timeoutValue - elapsed)
-          timeout.unref?.()
+          timeoutHandle = setTimeout(onTimeout, timeoutValue - elapsed)
+          timeoutHandle.unref?.()
         } else {
           for (const rec of records.filter((rec) => !rec.isReady)) {
             this._client._$onError(C.TOPIC.RECORD, C.EVENT.TIMEOUT, 'record timeout', [
@@ -222,8 +229,10 @@ class RecordHandler {
         rec.ref()
       }
 
-      timeout = setTimeout(onTimeout, 2 * 60e3)
-      timeout.unref?.()
+      if (timeoutValue) {
+        timeoutHandle = setTimeout(onTimeout, timeoutValue)
+        timeoutHandle.unref?.()
+      }
 
       signal?.addEventListener('abort', onAbort)
 
@@ -297,7 +306,7 @@ class RecordHandler {
     let path
     let state = defaults ? defaults.state : undefined
     let signal
-    let timeout = defaults ? defaults.timeout : undefined
+    let timeoutValue = defaults ? defaults.timeout : undefined
     let dataOnly = defaults ? defaults.dataOnly : undefined
 
     let idx = 0
@@ -316,7 +325,7 @@ class RecordHandler {
       signal = options.signal
 
       if (options.timeout != null) {
-        timeout = options.timeout
+        timeoutValue = options.timeout
       }
 
       if (options.path != null) {
@@ -350,7 +359,11 @@ class RecordHandler {
       )
     }
 
-    let x$ = new rxjs.Observable((o) => {
+    if (signal?.aborted) {
+      return rxjs.throwError(() => new utils.AbortError())
+    }
+
+    return new rxjs.Observable((o) => {
       let timeoutHandle
       let prevData = kEmpty
 
@@ -364,8 +377,9 @@ class RecordHandler {
           timeoutHandle = null
         }
 
+        const nextData = path ? record.get(path) : record.data
+
         if (dataOnly) {
-          const nextData = record.get(path)
           if (nextData !== prevData) {
             prevData = nextData
             o.next(nextData)
@@ -374,28 +388,25 @@ class RecordHandler {
           o.next({
             name: record.name,
             version: record.version,
-            data: record.get(path),
+            data: nextData,
             state: record.state,
           })
         }
       }
 
-      const record = this.getRecord(name)
+      const record = this.getRecord(name).subscribe(onUpdate)
 
-      record.subscribe(onUpdate)
-      record.unref()
-
-      if (timeout && state && record.state < state) {
+      if (timeoutValue && state && record.state < state) {
         timeoutHandle = setTimeout(() => {
           const expected = C.RECORD_STATE_NAME[state]
           const current = C.RECORD_STATE_NAME[record.state]
           o.error(
             Object.assign(
-              new Error(`timeout after ${timeout / 1e3}s: ${name} [${current}<${expected}]`),
+              new Error(`timeout after ${timeoutValue / 1e3}s: ${name} [${current}<${expected}]`),
               { code: 'ETIMEDOUT' }
             )
           )
-        }, timeout)
+        }, timeoutValue)
         timeoutHandle.unref?.()
       }
 
@@ -403,18 +414,17 @@ class RecordHandler {
         onUpdate(record)
       }
 
-      return () => {
-        record.unsubscribe(onUpdate)
+      const abort = () => {
+        o.error(new utils.AbortError())
       }
-    })
 
-    if (signal != null) {
-      // TODO (perf): This a slow way to implement.
-      x$ = signal.aborted ? rxjs.EMPTY : x$.pipe(rx.takeUntil(rxjs.fromEvent(signal, 'abort')))
-      x$ = x$.pipe(rx.throwIfEmpty(() => new utils.AbortError()))
-    }
+      signal?.addEventListener('abort', abort)
 
-    return x$
+      return () => {
+        record.unsubscribe(onUpdate).unref()
+        signal?.removeEventListener('abort', abort)
+      }
+    })
   }
 
   _$handle(message) {

package/src/record/record.js

@@ -46,34 +46,42 @@ class Record {
 
   ref() {
     this._refs += 1
-    this._handler._onRef(this)
     if (this._refs === 1) {
       this._subscribe()
     }
+
+    this._handler._onRef(this)
+
+    return this
   }
 
   unref() {
     invariant(this._refs > 0, this._name + ' missing refs')
 
     this._refs -= 1
+
     this._handler._onRef(this)
+
+    return this
   }
 
   subscribe(fn) {
     this._subscriptions.push(fn)
-    this.ref()
+
+    return this
   }
 
   unsubscribe(fn) {
     const idx = this._subscriptions.indexOf(fn)
     if (idx !== -1) {
       this._subscriptions.splice(idx, 1)
-      this.unref()
     }
+
+    return this
   }
 
   get(path) {
-    return jsonPath.get(this._data, path)
+    return path ? jsonPath.get(this._data, path) : this._data
   }
 
   set(pathOrData, dataOrNil) {
@@ -112,6 +120,7 @@ class Record {
     }
   }
 
+  // TODO (fix): timeout + signal
   when(stateOrNull) {
     invariant(this._refs > 0, this._name + ' missing refs')
 
@@ -132,11 +141,13 @@ class Record {
           return
         }
 
+        this.unref()
         this.unsubscribe(onUpdate)
 
         resolve(null)
       }
 
+      this.ref()
       this.subscribe(onUpdate)
     })
   }