@nxtedition/deepstream.io-client-js 23.4.36 → 23.4.37

package/package.json

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

package/src/record/record-handler.js

@@ -163,121 +163,55 @@ class RecordHandler {
     }
   }
 
-  sync(options) {
-    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 timeoutHandle
-
-      const records = [...this._pending]
-      for (const rec of records) {
-        rec.ref()
-      }
+  sync() {
+    return new Promise((resolve) => {
+      let counter = 0
 
-      const onDone = (val) => {
-        if (done) {
+      const onUpdate = (rec) => {
+        if (rec.pending) {
           return
         }
 
-        done = true
-
-        signal?.removeEventListener('abort', onAbort)
+        rec.unsubscribe(onUpdate)
+        rec.unref()
+        counter -= 1
 
-        if (timeoutHandle) {
-          timers.clearTimeout(timeoutHandle)
-          timeoutHandle = null
-        }
-
-        if (token) {
-          this._syncEmitter.off(token, onToken)
-          token = null
-        }
-
-        for (const rec of records) {
-          rec.unref()
+        if (counter > 0) {
+          return
         }
 
-        resolve(val)
-      }
-
-      const onToken = () => {
-        onDone(true)
-      }
-
-      const onAbort = () => {
-        onDone(Promise.reject(new utils.AbortError()))
-      }
-
-      const onTimeout = () => {
-        const elapsed = Date.now() - this._connected
-        if (elapsed < timeoutValue) {
-          timeoutHandle = timers.setTimeout(onTimeout, timeoutValue - elapsed)
-        } else {
-          for (const rec of records.filter((rec) => !rec.isReady)) {
-            this._client._$onError(C.TOPIC.RECORD, C.EVENT.TIMEOUT, 'record timeout', [
-              rec.name,
-              rec.version,
-              rec.state,
-              ...(rec._entry ?? []),
-            ])
-          }
-
-          this._client._$onError(C.TOPIC.RECORD, C.EVENT.TIMEOUT, 'sync timeout', [token])
+        if (!this._syncQueue) {
+          this._syncQueue = []
+          queueMicrotask(() => {
+            const syncQueue = this._syncQueue
+            if (!syncQueue) {
+              return
+            }
+
+            const token = xuid()
+
+            this._syncQueue = null
+            this._syncEmitter.once(token, () => {
+              for (const callback of syncQueue) {
+                callback()
+              }
+            })
 
-          onDone(false)
+            if (this._connected) {
+              this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, [token])
+            }
+          })
         }
-      }
 
-      if (timeoutValue) {
-        timeoutHandle = timers.setTimeout(onTimeout, timeoutValue)
+        this._syncQueue.push(resolve)
       }
 
-      signal?.addEventListener('abort', onAbort)
-
-      Promise.all(records.map((rec) => rec.when())).then(
-        () => {
-          if (done) {
-            return
-          }
-
-          if (!this._syncQueue) {
-            this._syncQueue = []
-            queueMicrotask(this._syncAll)
-          }
-
-          this._syncQueue.push(onToken)
-        },
-        (err) => onDone(Promise.reject(err))
-      )
-    })
-  }
-
-  _syncAll() {
-    if (!this._syncQueue) {
-      return
-    }
-
-    const syncQueue = this._syncQueue
-    const token = xuid()
-
-    this._syncQueue = null
-    this._syncEmitter.once(token, () => {
-      for (const callback of syncQueue) {
-        callback()
+      for (const rec of this._pending) {
+        rec.ref()
+        rec.subscribe(onUpdate)
+        counter += 1
       }
     })
-
-    if (this._connected) {
-      this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, [token])
-    }
   }
 
   set(name, ...args) {

package/src/record/record.js

@@ -19,6 +19,7 @@ class Record {
     this._refs = 1
     this._subscribed = false
     this._subscriptions = []
+    this._subscriptionsEmitting = false
     this._updating = null
     this._patches = null
     this._pending = false
@@ -72,12 +73,22 @@ class Record {
   }
 
   subscribe(fn) {
+    if (this._subscriptionsEmitting) {
+      this._subscriptions = this._subscriptions.slice()
+      this._subscriptionsEmitting = false
+    }
+
     this._subscriptions.push(fn)
 
     return this
   }
 
   unsubscribe(fn) {
+    if (this._subscriptionsEmitting) {
+      this._subscriptions = this._subscriptions.slice()
+      this._subscriptionsEmitting = false
+    }
+
     const idx = this._subscriptions.indexOf(fn)
     if (idx !== -1) {
       this._subscriptions.splice(idx, 1)
@@ -200,8 +211,13 @@ class Record {
   }
 
   _emitUpdate() {
-    for (const fn of this._subscriptions.slice()) {
-      fn(this)
+    try {
+      this._subscriptionsEmitting = true
+      for (const fn of this._subscriptions) {
+        fn(this)
+      }
+    } finally {
+      this._subscriptionsEmitting = false
     }
   }
 
@@ -266,6 +282,7 @@ class Record {
     if (!this._pending) {
       this._pending = true
       this._handler._onPending(this)
+      this._emitUpdate()
     }
 
     const connection = this._handler._connection
@@ -305,6 +322,7 @@ class Record {
     const prevData = this._data
     const prevVersion = this._version
     const prevState = this._state
+    const prevPending = this._pending
 
     if (this._updating?.delete(version)) {
       this._handler._stats.updating -= 1
@@ -337,7 +355,12 @@ class Record {
       this._state = this._version.charAt(0) === 'I' ? Record.STATE.STALE : Record.STATE.SERVER
     }
 
-    if (this._data !== prevData || this._version !== prevVersion || this._state !== prevState) {
+    if (
+      this._data !== prevData ||
+      this._version !== prevVersion ||
+      this._state !== prevState ||
+      this._pending !== prevPending
+    ) {
       this._emitUpdate()
     }
   }