@nxtedition/deepstream.io-client-js 28.1.16 → 28.1.18

package/package.json

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

package/src/record/record-handler.js

@@ -10,6 +10,8 @@ import * as utils from '../utils/utils.js'
 import xuid from 'xuid'
 import * as timers from '../utils/timers.js'
 
+function noop() {}
+
 const kEmpty = Symbol('kEmpty')
 
 function onUpdate(record, subscription) {
@@ -265,96 +267,118 @@ class RecordHandler {
 
   async sync(opts) {
     // TODO (fix): Sync pending? What about VOID state?
-
-    let onAbort
+    // TODO (perf): Slow implementation...
 
     const signal = opts?.signal
-    const timeout = opts?.timeout || 2 * 60e3
-
-    const signalPromise = signal
-      ? new Promise((resolve, reject) => {
-          onAbort = () => {
-            reject(signal.reason ?? new utils.AbortError())
-          }
-          signal.addEventListener('abort', onAbort)
-        })
-      : Promise.resolve()
-    signalPromise?.catch(() => {})
+    const timeout = opts?.timeout ?? 2 * 60e3
 
+    const disposers = []
     try {
+      const signalPromise = signal
+        ? new Promise((resolve, reject) => {
+            const onAbort = () => reject(signal.reason ?? new utils.AbortError())
+            signal.addEventListener('abort', onAbort)
+            disposers.push(() => signal.removeEventListener('abort', onAbort))
+          })
+        : null
+
+      signalPromise?.catch(noop)
+
       if (this._patching.size) {
-        let patchingTimeout
-        const patching = [...this._patching.values()]
+        const promises = []
 
-        await Promise.race([
-          Promise.all(
-            patching.map((callbacks) => new Promise((resolve) => callbacks.push(resolve))),
-          ),
-          new Promise((resolve) => {
-            patchingTimeout = timers.setTimeout(() => {
-              this._client._$onError(
-                C.TOPIC.RECORD,
-                C.EVENT.TIMEOUT,
-                new Error('sync patching timeout'),
-              )
-              resolve(null)
-            }, timeout)
-          }),
-          signalPromise,
-        ]).finally(() => {
-          timers.clearTimeout(patchingTimeout)
-        })
+        {
+          const patchingPromises = []
+          for (const callbacks of this._patching.values()) {
+            patchingPromises.push(new Promise((resolve) => callbacks.push(resolve)))
+          }
+          promises.push(patchingPromises)
+        }
+
+        if (timeout) {
+          promises.push(
+            new Promise((resolve) => {
+              const patchingTimeout = timers.setTimeout(() => {
+                this._client._$onError(
+                  C.TOPIC.RECORD,
+                  C.EVENT.TIMEOUT,
+                  new Error('sync patching timeout'),
+                )
+                resolve(null)
+              }, timeout)
+              disposers.push(() => timers.clearTimeout(patchingTimeout))
+            }),
+          )
+        }
+
+        if (signalPromise) {
+          promises.push(signalPromise)
+        }
+
+        await Promise.race(promises)
       }
 
       if (this._updating.size) {
-        let updatingTimeout
-        const updating = [...this._updating.values()]
+        const promises = []
 
-        await Promise.race([
-          Promise.all(
-            updating.map((callbacks) => new Promise((resolve) => callbacks.push(resolve))),
-          ),
+        {
+          const updatingPromises = []
+          for (const callbacks of this._updating.values()) {
+            updatingPromises.push(new Promise((resolve) => callbacks.push(resolve)))
+          }
+          promises.push(updatingPromises)
+        }
+
+        if (timeout) {
+          promises.push(
+            new Promise((resolve) => {
+              const updatingTimeout = timers.setTimeout(() => {
+                this._client._$onError(
+                  C.TOPIC.RECORD,
+                  C.EVENT.TIMEOUT,
+                  new Error('sync updating timeout'),
+                )
+                resolve(null)
+              }, timeout)
+              disposers.push(() => timers.clearTimeout(updatingTimeout))
+            }),
+          )
+        }
+
+        await Promise.race(promises)
+      }
+
+      {
+        const promises = []
+
+        promises.push(
           new Promise((resolve) => {
-            updatingTimeout = timers.setTimeout(() => {
-              this._client._$onError(
-                C.TOPIC.RECORD,
-                C.EVENT.TIMEOUT,
-                new Error('sync updating timeout'),
-              )
-              resolve(null)
-            }, timeout)
+            const token = xuid()
+            this._syncEmitter.once(token, resolve)
+            this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, [token])
           }),
-          signalPromise,
-        ]).finally(() => {
-          timers.clearTimeout(updatingTimeout)
-        })
-      }
+        )
+
+        if (timeout) {
+          promises.push(
+            new Promise((resolve, reject) => {
+              const serverTimeout = timers.setTimeout(() => {
+                reject(new Error('sync server timeout'))
+              }, timeout)
+              disposers.push(() => timers.clearTimeout(serverTimeout))
+            }),
+          )
+        }
 
-      let serverTimeout
-      const token = xuid()
+        if (signalPromise) {
+          promises.push(signalPromise)
+        }
 
-      return await Promise.race([
-        new Promise((resolve) => {
-          this._syncEmitter.once(token, resolve)
-          this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, [token])
-        }),
-        new Promise((resolve) => {
-          serverTimeout = timers.setTimeout(() => {
-            this._client._$onError(
-              C.TOPIC.RECORD,
-              C.EVENT.TIMEOUT,
-              new Error('sync server timeout'),
-            )
-            resolve(null)
-          }, timeout)
-        }),
-        signalPromise,
-      ]).finally(() => {
-        timers.clearTimeout(serverTimeout)
-      })
+        await Promise.race(promises)
+      }
     } finally {
-      if (onAbort) {
-        signal?.removeEventListener('abort', onAbort)
+      for (const disposer of disposers) {
+        disposer()
       }
     }
   }

package/src/utils/timers.js

@@ -78,6 +78,10 @@ class Timeout {
   clear() {
     this.state = -1
   }
+
+  [Symbol.dispose]() {
+    this.state = -1
+  }
 }
 
 export function setTimeout(callback, delay, opaque) {