@nxtedition/deepstream.io-client-js 31.2.4 → 31.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "31.2.4",
+  "version": "31.2.6",
   "description": "the javascript client for deepstream.io",
   "homepage": "http://deepstream.io",
   "type": "module",

package/src/record/record-handler.js

@@ -45,22 +45,18 @@ function onUpdate(record, subscription) {
 
   if (!subscription.synced || subscription.record.state < subscription.state) {
     if (subscription.timeoutValue > 0) {
-      if (!subscription.timeoutHandle) {
-        subscription.timeoutHandle = timers.setTimeout(
-          onTimeout,
-          subscription.timeoutValue,
-          subscription,
-        )
+      if (!subscription.timeout) {
+        subscription.timeout = timers.setTimeout(onTimeout, subscription.timeoutValue, subscription)
       } else {
-        subscription.timeoutHandle.refresh()
+        subscription.timeout.refresh()
       }
     }
     return
   }
 
-  if (subscription.timeoutHandle) {
-    timers.clearTimeout(subscription.timeoutHandle)
-    subscription.timeoutHandle = null
+  if (subscription.timeout) {
+    timers.clearTimeout(subscription.timeout)
+    subscription.timeout = null
   }
 
   const data = subscription.path
@@ -472,30 +468,31 @@ class RecordHandler {
   }
 
   /**
+   * @param {string} name
    * @param  {...any} args
    * @returns {rxjs.Observable}
    */
-  observe(...args) {
-    return this._observe(OBSERVE_DEFAULTS, ...args)
+  observe(name, ...args) {
+    return this._observe(OBSERVE_DEFAULTS, name, ...args)
   }
 
   /**
+   * @param {string} name
    * @param  {...any} args
    * @returns {rxjs.Observable<{ name: string, version: string, state: Number, data: any}>}
    */
-  observe2(...args) {
-    return this._observe(OBSERVE2_DEFAULTS, ...args)
+  observe2(name, ...args) {
+    return this._observe(OBSERVE2_DEFAULTS, name, ...args)
   }
 
   /**
-   *
-   * @param {*} name
+   * @param {string} name
    * @param  {...any} args
    * @returns { { value: object, async: false } | { value: Promise<object>, async: true } }
    */
   getAsync(name, ...args) {
     let path
-    let state = GET_DEFAULTS.state
+    let state = GET_DEFAULTS.state ?? C.RECORD_STATE.CLIENT
 
     let idx = 0
 
@@ -517,32 +514,40 @@ class RecordHandler {
       return { value: this.get(name, ...args), async: true }
     }
 
+    if (typeof state === 'string') {
+      state = C.RECORD_STATE[state.toUpperCase()]
+    }
+
+    if (!Number.isInteger(state) || state < 0) {
+      throw new Error('invalid argument: state')
+    }
+
     const rec = this.getRecord(name)
     try {
-      if (rec.state >= state) {
-        return { value: rec.get(path), async: false }
-      }
+      return rec.state >= state
+        ? { value: rec.get(path), async: false }
+        : { value: this.get(name, ...args), async: true }
     } finally {
       rec.unref()
     }
-
-    return { value: this.get(name, ...args), async: true }
   }
 
   /**
+   * @param {string} name
    * @param  {...any} args
    * @returns {Promise<object>}
    */
-  get(...args) {
-    return rxjs.firstValueFrom(this._observe(GET_DEFAULTS, ...args))
+  get(name, ...args) {
+    return rxjs.firstValueFrom(this._observe(GET_DEFAULTS, name, ...args))
   }
 
   /**
+   * @param {string} name
    * @param  {...any} args
    * @returns {Promise<object>}
    */
-  get2(...args) {
-    return rxjs.firstValueFrom(this._observe(GET2_DEFAULTS, ...args))
+  get2(name, ...args) {
+    return rxjs.firstValueFrom(this._observe(GET2_DEFAULTS, name, ...args))
   }
 
   /**
@@ -605,9 +610,6 @@ class RecordHandler {
         state = C.RECORD_STATE[state.toUpperCase()]
       }
 
-      // TODO (fix): Validate path?
-      // TODO (fix): Validate signal?
-
       if (!Number.isInteger(state) || state < 0) {
         throw new Error('invalid argument: state')
       }
@@ -628,8 +630,6 @@ class RecordHandler {
       const subscription = {
         /** @readonly @type {unknown} */
         subscriber,
-        /** @type {Record|null} */
-        record: this.getRecord(name),
         /** @readonly @type {unknown} */
         path,
         /** @readonly @type {number} */
@@ -641,53 +641,51 @@ class RecordHandler {
         /** @readonly @type {number} */
         timeoutValue: timeout,
 
+        /** @type {Record|null} */
+        record: null,
         /** @type {Timeout|null} */
-        timeoutHandle: null,
+        timeout: null,
         /** @type {Function?} */
         abort: null,
         /** @type {object|Array} */
         data: kEmpty,
         /** @type {boolean} */
         synced: false,
-
-        unsubscribe() {
-          if (this.timeoutHandle) {
-            timers.clearTimeout(this.timeoutHandle)
-            this.timeoutHandle = null
-          }
-
-          if (this.signal) {
-            utils.removeAbortListener(this.signal, this.abort)
-            this.abort = null
-            this.signal = null
-          }
-
-          if (this.record) {
-            this.record.unsubscribe(onUpdate, this)
-            this.record.unref()
-            this.record = null
-          }
-        },
       }
 
-      if (subscription.record) {
-        subscription.record.subscribe(onUpdate, subscription)
+      subscriber.add(() => {
+        if (subscription.timeout) {
+          timers.clearTimeout(subscription.timeout)
+          subscription.timeout = null
+        }
 
-        if (sync && subscription.record.state >= C.RECORD_STATE.SERVER) {
-          this._sync(onSync, sync === true ? 'WEAK' : sync, subscription)
-        } else {
-          subscription.synced = true
+        if (subscription.signal) {
+          utils.removeAbortListener(subscription.signal, subscription.abort)
+          subscription.abort = null
+          subscription.signal = null
         }
-      }
+
+        if (subscription.record) {
+          subscription.record.unsubscribe(onUpdate, subscription)
+          subscription.record.unref()
+          subscription.record = null
+        }
+      })
 
       if (subscription.signal) {
         subscription.abort = () => subscriber.error(new utils.AbortError())
         utils.addAbortListener(subscription.signal, subscription.abort)
       }
 
-      onUpdate(subscription.record, subscription)
+      subscription.record = this.getRecord(name).subscribe(onUpdate, subscription)
 
-      return subscription
+      if (sync) {
+        this._sync(onSync, sync === true ? 'WEAK' : sync, subscription)
+      } else {
+        subscription.synced = true
+      }
+
+      onUpdate(subscription.record, subscription)
     })
   }