@nxtedition/deepstream.io-client-js 32.0.17 → 32.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "32.0.17",
+  "version": "32.0.19",
   "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 LegacyListener from '../utils/legacy-listener.js'
+import MulticastListener from '../utils/multicast-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 LegacyListener(C.TOPIC.EVENT, pattern, callback, this, options)
+      : new MulticastListener(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 LegacyListener from '../utils/legacy-listener.js'
+import MulticastListener from '../utils/multicast-listener.js'
 import UnicastListener from '../utils/unicast-listener.js'
 import * as C from '../constants/constants.js'
 import * as rxjs from 'rxjs'
@@ -35,7 +35,7 @@ const GET2_DEFAULTS = {
 
 function onSync(subscription) {
   subscription.synced = true
-  onUpdate(null, subscription)
+  onUpdate(subscription.record, subscription)
 }
 
 function onUpdate(record, subscription) {
@@ -84,18 +84,9 @@ function onTimeout(subscription) {
 
   subscription.subscriber.error(
     Object.assign(
-      new Error(
-        !subscription.synced
-          ? `timeout sync: ${subscription.record.name}`
-          : `timeout state: ${subscription.record.name} [${current}<${expected}]`,
-      ),
+      new Error(`timeout state: ${subscription.record.name} [${current}<${expected}]`),
       {
         code: 'ETIMEDOUT',
-        timeout: subscription.timeoutValue,
-        expected,
-        current,
-        synced: subscription.synced,
-        name: subscription.record.name,
       },
     ),
   )
@@ -119,12 +110,16 @@ class RecordHandler {
 
     this._connected = 0
     this._stats = {
+      updating: 0,
       created: 0,
       destroyed: 0,
+      records: 0,
+      pruning: 0,
+      patching: 0,
     }
 
     this._syncQueue = []
-    this._syncMap = new Map()
+    this._syncMap = {}
 
     this.set = this.set.bind(this)
     this.get = this.get.bind(this)
@@ -146,6 +141,8 @@ class RecordHandler {
         this._records.delete(rec.name)
       }
 
+      this._stats.pruning -= pruning.size
+      this._stats.records -= pruning.size
       this._stats.destroyed += pruning.size
 
       this._pruningTimeout.refresh()
@@ -155,6 +152,12 @@ class RecordHandler {
   }
 
   _onPruning(rec, value) {
+    if (value) {
+      this._stats.pruning += 1
+    } else {
+      this._stats.pruning -= 1
+    }
+
     if (value) {
       this._pruning.add(rec)
     } else {
@@ -167,9 +170,12 @@ class RecordHandler {
 
     if (value) {
       invariant(!callbacks, 'updating callbacks must not exist')
+      this._stats.updating += 1
       this._updating.set(rec, [])
     } else {
       invariant(callbacks, 'updating callbacks must exist')
+
+      this._stats.updating -= 1
       this._updating.delete(rec)
       for (const callback of callbacks) {
         callback()
@@ -179,8 +185,11 @@ class RecordHandler {
 
   _onPatching(rec, value) {
     if (value) {
+      this._stats.patching += 1
       this._patching.set(rec, [])
     } else {
+      this._stats.patching -= 1
+
       const callbacks = this._patching.get(rec)
       this._patching.delete(rec)
       for (const callback of callbacks) {
@@ -202,10 +211,6 @@ class RecordHandler {
     return {
       ...this._stats,
       subscriptions,
-      updating: this._updating.size,
-      patching: this._patching.size,
-      putting: this._putting.size,
-      pruning: this._pruning.size,
     }
   }
 
@@ -214,23 +219,19 @@ class RecordHandler {
    * @returns {Record}
    */
   getRecord(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,
-      )
-    }
+    invariant(
+      typeof name === 'string' &&
+        name.length > 0 &&
+        name !== '[object Object]' &&
+        name.length <= 4096,
+      `invalid name ${name}`,
+    )
 
     let record = this._records.get(name)
 
     if (!record) {
       record = new Record(name, this)
+      this._stats.records += 1
       this._stats.created += 1
       this._records.set(name, record)
     }
@@ -260,7 +261,7 @@ class RecordHandler {
     const listener =
       options.mode?.toLowerCase() === 'unicast'
         ? new UnicastListener(C.TOPIC.RECORD, pattern, callback, this, options)
-        : new LegacyListener(C.TOPIC.RECORD, pattern, callback, this, options)
+        : new MulticastListener(C.TOPIC.RECORD, pattern, callback, this, options)
 
     this._stats.listeners += 1
     this._listeners.set(pattern, listener)
@@ -281,7 +282,7 @@ class RecordHandler {
     // TODO (perf): Slow implementation...
 
     const signal = opts?.signal
-    const timeout = opts?.timeout ?? 10 * 60e3
+    const timeout = opts?.timeout
 
     let disposers
     try {
@@ -297,17 +298,18 @@ class RecordHandler {
       signalPromise?.catch(noop)
 
       if (this._patching.size) {
-        const promises = []
+        let promises
 
         {
           const patchingPromises = []
           for (const callbacks of this._patching.values()) {
             patchingPromises.push(new Promise((resolve) => callbacks.push(resolve)))
           }
+          promises ??= []
           promises.push(Promise.all(patchingPromises))
         }
 
-        if (timeout && promises.length) {
+        if (timeout) {
           promises.push(
             new Promise((resolve) => {
               const patchingTimeout = timers.setTimeout(() => {
@@ -324,28 +326,30 @@ class RecordHandler {
           )
         }
 
-        if (signalPromise && promises.length) {
+        if (signalPromise) {
+          promises ??= []
           promises.push(signalPromise)
         }
 
-        if (promises.length) {
+        if (promises) {
           await Promise.race(promises)
-          signal?.throwIfAborted()
         }
       }
 
       if (this._updating.size) {
-        const promises = []
+        let promises
 
         {
           const updatingPromises = []
           for (const callbacks of this._updating.values()) {
             updatingPromises.push(new Promise((resolve) => callbacks.push(resolve)))
           }
+          promises ??= []
           promises.push(Promise.all(updatingPromises))
         }
 
-        if (timeout && promises.length) {
+        if (timeout) {
+          promises ??= []
           promises.push(
             new Promise((resolve) => {
               const updatingTimeout = timers.setTimeout(() => {
@@ -362,22 +366,18 @@ class RecordHandler {
           )
         }
 
-        if (signalPromise && promises.length) {
-          promises.push(signalPromise)
-        }
-
-        if (promises.length) {
+        if (promises) {
           await Promise.race(promises)
-          signal?.throwIfAborted()
         }
       }
 
       {
-        const promises = []
+        const syncPromise = new Promise((resolve) => this._sync(resolve))
 
-        promises.push(new Promise((resolve) => this._sync(resolve)))
+        let promises
 
         if (timeout) {
+          promises ??= []
           promises.push(
             new Promise((resolve, reject) => {
               const serverTimeout = timers.setTimeout(() => {
@@ -390,12 +390,15 @@ class RecordHandler {
         }
 
         if (signalPromise) {
+          promises ??= []
           promises.push(signalPromise)
         }
 
-        if (promises.length) {
+        if (promises) {
+          promises.push(syncPromise)
           await Promise.race(promises)
-          signal?.throwIfAborted()
+        } else {
+          await syncPromise
         }
       }
     } finally {
@@ -551,81 +554,76 @@ class RecordHandler {
    * @returns {rxjs.Observable}
    */
   _observe(defaults, name, ...args) {
-    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
+    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++]
+      }
 
-    let idx = 0
+      if (idx < args.length && (args[idx] == null || typeof args[idx] === 'number')) {
+        state = args[idx++]
+      }
 
-    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] === 'object')) {
+        const options = args[idx++] || {}
 
-    if (idx < args.length && (args[idx] == null || typeof args[idx] === 'number')) {
-      state = args[idx++]
-    }
+        if (options.signal !== undefined) {
+          signal = options.signal
+        }
 
-    if (idx < args.length && (args[idx] == null || typeof args[idx] === 'object')) {
-      const options = args[idx] ?? {}
+        if (options.timeout !== undefined) {
+          timeout = options.timeout
+        }
 
-      if (options.signal !== undefined) {
-        signal = options.signal
-      }
+        if (options.path !== undefined) {
+          path = options.path
+        }
 
-      if (options.timeout !== undefined) {
-        timeout = options.timeout
-      }
+        if (options.state !== undefined) {
+          state = options.state
+        }
 
-      if (options.path !== undefined) {
-        path = options.path
-      }
+        if (options.dataOnly !== undefined) {
+          dataOnly = options.dataOnly
+        }
 
-      if (options.state !== undefined) {
-        state = options.state
+        if (options.sync !== undefined) {
+          sync = options.sync
+        }
       }
 
-      if (options.dataOnly !== undefined) {
-        dataOnly = options.dataOnly
+      if (typeof state === 'string') {
+        state = C.RECORD_STATE[state.toUpperCase()]
       }
 
-      if (options.sync !== undefined) {
-        sync = options.sync
+      if (!Number.isInteger(state) || state < 0) {
+        throw new Error('invalid argument: state')
       }
-    }
-
-    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 (!Number.isInteger(timeout) || timeout < 0) {
+        throw new Error('invalid argument: timeout')
+      }
 
-    if (typeof sync !== 'boolean') {
-      throw new Error('invalid argument: sync')
-    }
+      if (typeof dataOnly !== 'boolean') {
+        throw new Error('invalid argument: dataOnly')
+      }
 
-    return new rxjs.Observable((subscriber) => {
-      if (signal?.aborted) {
-        subscriber.error(new utils.AbortError())
-        return
+      if (typeof sync !== 'boolean') {
+        throw new Error('invalid argument: sync')
       }
 
       // TODO (perf): Make a class
@@ -653,9 +651,6 @@ class RecordHandler {
         data: kEmpty,
         /** @type {boolean} */
         synced: false,
-
-        index: -1,
-        onUpdate,
       }
 
       subscriber.add(() => {
@@ -671,7 +666,7 @@ class RecordHandler {
         }
 
         if (subscription.record) {
-          subscription.record._unobserve(subscription)
+          subscription.record.unsubscribe(onUpdate, subscription)
           subscription.record.unref()
           subscription.record = null
         }
@@ -682,11 +677,11 @@ class RecordHandler {
         utils.addAbortListener(subscription.signal, subscription.abort)
       }
 
-      subscription.record = this.getRecord(name)
-      subscription.record._observe(subscription)
+      subscription.record = this.getRecord(name).subscribe(onUpdate, subscription)
 
       if (sync) {
-        this._sync(onSync, sync, subscription)
+        // TODO (fix): What about sync timeout?
+        this._sync(onSync, sync === true ? 'WEAK' : sync, subscription)
       } else {
         onSync(subscription)
       }
@@ -707,8 +702,8 @@ class RecordHandler {
         return true
       }
 
-      const sync = this._syncMap.get(token)
-      this._syncMap.delete(token)
+      const sync = this._syncMap[token]
+      delete this._syncMap[token]
 
       if (!sync) {
         return true
@@ -751,10 +746,10 @@ class RecordHandler {
         this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.PUT, update)
       }
 
-      const syncMap = new Map()
-      for (const sync of this._syncMap.values()) {
+      const syncMap = {}
+      for (const sync of Object.values(this._syncMap)) {
         const token = xuid()
-        syncMap.set(token, sync)
+        syncMap[token] = sync
         this._connection.sendMsg(
           C.TOPIC.RECORD,
           C.ACTIONS.SYNC,
@@ -789,7 +784,7 @@ class RecordHandler {
       const token = xuid()
       const queue = this._syncQueue.splice(0)
 
-      this._syncMap.set(token, { queue, type })
+      this._syncMap[token] = { queue, type }
       this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, type ? [token, type] : [token])
     }, 1)
   }

package/src/record/record.js

@@ -16,17 +16,11 @@ class Record {
     this._handler = handler
     this._name = name
     this._version = ''
-    this._data = jsonPath.EMPTY_OBJ
+    this._data = jsonPath.EMPTY
     this._state = C.RECORD_STATE.VOID
     this._refs = 0
     this._subscriptions = []
-
-    /** @type {Array|null} */
-    this._emittingArr = null
-    /** @type {number} */
-    this._emittingIndex = -1
-
-    this._observers = []
+    this._emitting = false
 
     /** @type Map? */ this._updating = null
     /** @type Array? */ this._patching = null
@@ -94,8 +88,9 @@ class Record {
    * @returns {Record}
    */
   subscribe(fn, opaque = null) {
-    if (this._emittingArr == this._subscriptions) {
+    if (this._emitting) {
       this._subscriptions = this._subscriptions.slice()
+      this._emitting = false
     }
 
     this._subscriptions.push(fn, opaque)
@@ -110,8 +105,9 @@ class Record {
    * @returns {Record}
    */
   unsubscribe(fn, opaque = null) {
-    if (this._emittingArr == this._subscriptions) {
+    if (this._emitting) {
       this._subscriptions = this._subscriptions.slice()
+      this._emitting = false
     }
 
     let idx = -1
@@ -132,41 +128,6 @@ 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
@@ -229,7 +190,7 @@ class Record {
   when(stateOrNil, optionsOrNil) {
     invariant(this._refs > 0, 'missing refs')
 
-    if (stateOrNil != null && typeof stateOrNil === 'object') {
+    if (stateOrNil != null && stateOrNil === 'object') {
       optionsOrNil = stateOrNil
       stateOrNil = optionsOrNil?.state
     }
@@ -253,14 +214,8 @@ class Record {
       }
 
       let timeoutHandle
-      let done = false
 
       const onDone = (err) => {
-        if (done) {
-          return
-        }
-        done = true
-
         if (err) {
           reject(err)
         } else {
@@ -560,41 +515,18 @@ class Record {
   }
 
   _emitUpdate() {
-    if (this._emittingArr != null) {
-      throw new Error('cannot reenter emitUpdate')
-    }
+    this._emitting = true
 
-    try {
-      const arr = this._subscriptions
-      const len = arr.length
-
-      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
-    }
-
-    try {
-      const arr = this._observers
-      const len = arr.length
+    const arr = this._subscriptions
+    const len = arr.length
 
-      this._emittingArr = arr
-      for (let n = 0; n < len; n++) {
-        this._emittingIndex = n
-        // TODO (fix): What if this throws?
-        arr[n].onUpdate(this, arr[n])
-      }
-    } finally {
-      this._emittingArr = null
-      this._emittingIndex = -1
+    for (let n = 0; n < len; n += 2) {
+      arr[n + 0](this, arr[n + 1])
     }
 
     this._handler._client.emit('recordUpdated', this)
+
+    this._emitting = false
   }
 }
 

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

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

package/src/utils/utils.js

@@ -3,8 +3,6 @@ import xxhash from 'xxhash-wasm'
 const NODE_ENV = typeof process !== 'undefined' && process.env && process.env.NODE_ENV
 const HASHER = await xxhash()
 
-// This is a hack to avoid top-level await
-// const HASHER = await xxhash()
 export const isNode = typeof process !== 'undefined' && process.toString() === '[object process]'
 export const isProduction = NODE_ENV === 'production'
 
@@ -83,14 +81,6 @@ export function setTimeout(callback, timeoutDuration) {
   }
 }
 
-export function setInterval(callback, intervalDuration) {
-  if (intervalDuration !== null) {
-    return globalThis.setInterval(callback, intervalDuration)
-  } else {
-    return -1
-  }
-}
-
 export function compareRev(a, b) {
   if (!a) {
     return b ? -1 : 0