@nxtedition/deepstream.io-client-js 31.2.16 → 31.2.18

package/package.json

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

package/src/event/event-handler.js

@@ -1,7 +1,7 @@
 import * as C from '../constants/constants.js'
 import * as messageBuilder from '../message/message-builder.js'
 import * as messageParser from '../message/message-parser.js'
-import MulticastListener from '../utils/multicast-listener.js'
+import LegacyListener from '../utils/legacy-listener.js'
 import UnicastListener from '../utils/unicast-listener.js'
 import EventEmitter from 'component-emitter2'
 import * as rxjs from 'rxjs'
@@ -126,7 +126,7 @@ EventHandler.prototype.provide = function (pattern, callback, options) {
   const listener =
     options.mode?.toLowerCase() === 'unicast'
       ? new UnicastListener(C.TOPIC.EVENT, pattern, callback, this, options)
-      : new MulticastListener(C.TOPIC.EVENT, pattern, callback, this, options)
+      : new LegacyListener(C.TOPIC.EVENT, pattern, callback, this, options)
 
   this._listeners.set(pattern, listener)
   return () => {

package/src/record/record-handler.js

@@ -1,5 +1,5 @@
 import Record from './record.js'
-import MulticastListener from '../utils/multicast-listener.js'
+import LegacyListener from '../utils/legacy-listener.js'
 import UnicastListener from '../utils/unicast-listener.js'
 import * as C from '../constants/constants.js'
 import * as rxjs from 'rxjs'
@@ -84,9 +84,18 @@ function onTimeout(subscription) {
 
   subscription.subscriber.error(
     Object.assign(
-      new Error(`timeout state: ${subscription.record.name} [${current}<${expected}]`),
+      new Error(
+        !subscription.synced
+          ? `timeout sync: ${subscription.record.name}`
+          : `timeout state: ${subscription.record.name} [${current}<${expected}]`,
+      ),
       {
         code: 'ETIMEDOUT',
+        timeout: subscription.timeoutValue,
+        expected,
+        current,
+        synced: subscription.synced,
+        name: subscription.record.name,
       },
     ),
   )
@@ -119,7 +128,7 @@ class RecordHandler {
     }
 
     this._syncQueue = []
-    this._syncMap = {}
+    this._syncMap = new Map()
 
     this.set = this.set.bind(this)
     this.get = this.get.bind(this)
@@ -219,13 +228,18 @@ class RecordHandler {
    * @returns {Record}
    */
   getRecord(name) {
-    invariant(
-      typeof name === 'string' &&
-        name.length > 0 &&
-        name !== '[object Object]' &&
-        name.length <= 4096,
-      `invalid name ${name}`,
-    )
+    if (typeof name !== 'string' || name.length === 0) {
+      throw new Error('invalid argument: name')
+    }
+
+    if (name.startsWith('null') || name.startsWith('undefined') || name === '[object Object]') {
+      this._client._$onError(
+        C.TOPIC.RECORD,
+        C.EVENT.USER_ERROR,
+        'name should not start with null or undefined',
+        name,
+      )
+    }
 
     let record = this._records.get(name)
 
@@ -261,7 +275,7 @@ class RecordHandler {
     const listener =
       options.mode?.toLowerCase() === 'unicast'
         ? new UnicastListener(C.TOPIC.RECORD, pattern, callback, this, options)
-        : new MulticastListener(C.TOPIC.RECORD, pattern, callback, this, options)
+        : new LegacyListener(C.TOPIC.RECORD, pattern, callback, this, options)
 
     this._stats.listeners += 1
     this._listeners.set(pattern, listener)
@@ -552,78 +566,78 @@ class RecordHandler {
    * @returns {rxjs.Observable}
    */
   _observe(defaults, name, ...args) {
-    return new rxjs.Observable((subscriber) => {
-      let path
-      let state = defaults?.state ?? C.RECORD_STATE.CLIENT
-      let signal = null
-      let timeout = defaults?.timeout ?? 0
-      let dataOnly = defaults?.dataOnly ?? false
-      let sync = defaults?.sync ?? false
-
-      let idx = 0
-
-      if (
-        idx < args.length &&
-        (args[idx] == null ||
-          typeof args[idx] === 'string' ||
-          Array.isArray(args[idx]) ||
-          typeof args[idx] === 'function')
-      ) {
-        path = args[idx++]
-      }
-
-      if (idx < args.length && (args[idx] == null || typeof args[idx] === 'number')) {
-        state = args[idx++]
-      }
-
-      if (idx < args.length && (args[idx] == null || typeof args[idx] === 'object')) {
-        const options = args[idx++] || {}
-
-        if (options.signal !== undefined) {
-          signal = options.signal
-        }
+    let path
+    let state = defaults?.state ?? C.RECORD_STATE.CLIENT
+    let signal = null
+    let timeout = defaults?.timeout ?? 0
+    let dataOnly = defaults?.dataOnly ?? false
+    let sync = defaults?.sync ?? false
 
-        if (options.timeout !== undefined) {
-          timeout = options.timeout
-        }
+    let idx = 0
 
-        if (options.path !== undefined) {
-          path = options.path
-        }
+    if (
+      idx < args.length &&
+      (args[idx] == null ||
+        typeof args[idx] === 'string' ||
+        Array.isArray(args[idx]) ||
+        typeof args[idx] === 'function')
+    ) {
+      path = args[idx++]
+    }
 
-        if (options.state !== undefined) {
-          state = options.state
-        }
+    if (idx < args.length && (args[idx] == null || typeof args[idx] === 'number')) {
+      state = args[idx++]
+    }
 
-        if (options.dataOnly !== undefined) {
-          dataOnly = options.dataOnly
-        }
+    if (idx < args.length && (args[idx] == null || typeof args[idx] === 'object')) {
+      const options = args[idx++] || {}
 
-        if (options.sync !== undefined) {
-          sync = options.sync
-        }
+      if (options.signal !== undefined) {
+        signal = options.signal
       }
 
-      if (typeof state === 'string') {
-        state = C.RECORD_STATE[state.toUpperCase()]
+      if (options.timeout !== undefined) {
+        timeout = options.timeout
       }
 
-      if (!Number.isInteger(state) || state < 0) {
-        throw new Error('invalid argument: state')
+      if (options.path !== undefined) {
+        path = options.path
       }
 
-      if (!Number.isInteger(timeout) || timeout < 0) {
-        throw new Error('invalid argument: timeout')
+      if (options.state !== undefined) {
+        state = options.state
       }
 
-      if (typeof dataOnly !== 'boolean') {
-        throw new Error('invalid argument: dataOnly')
+      if (options.dataOnly !== undefined) {
+        dataOnly = options.dataOnly
       }
 
-      if (typeof sync !== 'boolean') {
-        throw new Error('invalid argument: sync')
+      if (options.sync !== undefined) {
+        sync = options.sync
       }
+    }
+
+    if (typeof state === 'string') {
+      state = C.RECORD_STATE[state.toUpperCase()]
+    }
 
+    if (!Number.isInteger(state) || state < 0) {
+      throw new Error('invalid argument: state')
+    }
+
+    if (!Number.isInteger(timeout) || timeout < 0) {
+      throw new Error('invalid argument: timeout')
+    }
+
+    if (typeof dataOnly !== 'boolean') {
+      throw new Error('invalid argument: dataOnly')
+    }
+
+    if (typeof sync !== 'boolean') {
+      throw new Error('invalid argument: sync')
+    }
+
+    return new rxjs.Observable((subscriber) => {
       // TODO (perf): Make a class
       const subscription = {
         /** @readonly @type {unknown} */
@@ -649,6 +663,9 @@ class RecordHandler {
         data: kEmpty,
         /** @type {boolean} */
         synced: false,
+
+        index: -1,
+        onUpdate,
       }
 
       subscriber.add(() => {
@@ -664,7 +681,7 @@ class RecordHandler {
         }
 
         if (subscription.record) {
-          subscription.record.unsubscribe(onUpdate, subscription)
+          subscription.record._unobserve(subscription)
           subscription.record.unref()
           subscription.record = null
         }
@@ -675,11 +692,11 @@ class RecordHandler {
         utils.addAbortListener(subscription.signal, subscription.abort)
       }
 
-      subscription.record = this.getRecord(name).subscribe(onUpdate, subscription)
+      subscription.record = this.getRecord(name)
+      subscription.record._observe(subscription)
 
       if (sync) {
-        // TODO (fix): What about sync timeout?
-        this._sync(onSync, sync === true ? 'WEAK' : sync, subscription)
+        this._sync(onSync, sync, subscription)
       } else {
         onSync(subscription)
       }
@@ -700,8 +717,8 @@ class RecordHandler {
         return true
       }
 
-      const sync = this._syncMap[token]
-      delete this._syncMap[token]
+      const sync = this._syncMap.get(token)
+      this._syncMap.delete(token)
 
       if (!sync) {
         return true
@@ -744,10 +761,10 @@ class RecordHandler {
         this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.PUT, update)
       }
 
-      const syncMap = {}
-      for (const sync of Object.values(this._syncMap)) {
+      const syncMap = new Map()
+      for (const sync of this._syncMap.values()) {
         const token = xuid()
-        syncMap[token] = sync
+        syncMap.set(token, sync)
         this._connection.sendMsg(
           C.TOPIC.RECORD,
           C.ACTIONS.SYNC,
@@ -782,7 +799,7 @@ class RecordHandler {
       const token = xuid()
       const queue = this._syncQueue.splice(0)
 
-      this._syncMap[token] = { queue, type }
+      this._syncMap.set(token, { queue, type })
       this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, type ? [token, type] : [token])
     }, 1)
   }

package/src/record/record.js

@@ -20,7 +20,13 @@ class Record {
     this._state = C.RECORD_STATE.VOID
     this._refs = 0
     this._subscriptions = []
-    this._emitting = false
+
+    /** @type {Array|null} */
+    this._emittingArr = null
+    /** @type {number} */
+    this._emittingIndex = -1
+
+    this._observers = []
 
     /** @type Map? */ this._updating = null
     /** @type Array? */ this._patching = null
@@ -88,9 +94,8 @@ class Record {
    * @returns {Record}
    */
   subscribe(fn, opaque = null) {
-    if (this._emitting) {
+    if (this._emittingArr == this._subscriptions) {
       this._subscriptions = this._subscriptions.slice()
-      this._emitting = false
     }
 
     this._subscriptions.push(fn, opaque)
@@ -105,9 +110,8 @@ class Record {
    * @returns {Record}
    */
   unsubscribe(fn, opaque = null) {
-    if (this._emitting) {
+    if (this._emittingArr == this._subscriptions) {
       this._subscriptions = this._subscriptions.slice()
-      this._emitting = false
     }
 
     let idx = -1
@@ -128,6 +132,41 @@ class Record {
     return this
   }
 
+  /**
+   * @note Subscribers are unordered.
+   * @param {{ index: number, onUpdate: (Record) => void}} subscription
+   */
+  _observe(subscription) {
+    if (subscription.index != null && subscription.index !== -1) {
+      throw new Error('already observing')
+    }
+
+    subscription.index = this._observers.push(subscription) - 1
+  }
+
+  /**
+   * @param {{ index: number, onUpdate: (Record) => void}} subscription
+   */
+  _unobserve(subscription) {
+    if (subscription.index == null || subscription.index === -1) {
+      throw new Error('not observing')
+    }
+
+    if (this._emittingArr === this._observers) {
+      // TODO (perf): Shift from start if emitting?
+      this._observers = this._observers.slice()
+    }
+
+    const idx = subscription.index
+    const tmp = this._observers.pop()
+    subscription.index = -1
+
+    if (tmp !== subscription) {
+      this._observers[idx] = tmp
+      this._observers[idx].index = idx
+    }
+  }
+
   get(path) {
     if (!path) {
       return this._data
@@ -515,18 +554,41 @@ class Record {
   }
 
   _emitUpdate() {
-    this._emitting = true
+    if (this._emittingArr != null) {
+      throw new Error('cannot reenter emitUpdate')
+    }
 
-    const arr = this._subscriptions
-    const len = arr.length
+    try {
+      const arr = this._subscriptions
+      const len = arr.length
 
-    for (let n = 0; n < len; n += 2) {
-      arr[n + 0](this, arr[n + 1])
+      this._emittingArr = arr
+      for (let n = 0; n < len; n += 2) {
+        this._emittingIndex = n
+        // TODO (fix): What if this throws?
+        arr[n + 0](this, arr[n + 1])
+      }
+    } finally {
+      this._emittingArr = null
+      this._emittingIndex = -1
     }
 
-    this._handler._client.emit('recordUpdated', this)
+    try {
+      const arr = this._observers
+      const len = arr.length
 
-    this._emitting = false
+      this._emittingArr = arr
+      for (let n = 0; n < len; n++) {
+        this._emittingIndex = n
+        // TODO (fix): What if this throws?
+        arr[n].onUpdate(this)
+      }
+    } finally {
+      this._emittingArr = null
+      this._emittingIndex = -1
+    }
+
+    this._handler._client.emit('recordUpdated', this)
   }
 }
 

package/src/utils/{multicast-listener.js → legacy-listener.js}

@@ -1,6 +1,6 @@
 import * as rxjs from 'rxjs'
 import * as C from '../constants/constants.js'
-import { h64ToString, findBigIntPaths } from '../utils/utils.js'
+import { h64ToString, findBigIntPaths } from './utils.js'
 
 export default class Listener {
   constructor(topic, pattern, callback, handler, { recursive = false, stringify = null } = {}) {