@nxtedition/deepstream.io-client-js 28.0.1 → 30.0.0

package/package.json

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

package/src/message/message-builder.js

@@ -1,81 +1,25 @@
 import * as C from '../constants/constants.js'
-import * as utils from '../utils/utils.js'
 
-const poolEncoder = new globalThis.TextEncoder()
-
-// TODO (fix): Don't assume maxMesageSize is 1MB
-const maxMessageSize = 1024 * 1024
-const poolSize = maxMessageSize * 8
-
-let poolBuffer
-let poolOffset
-
-function reallocPool() {
-  poolBuffer = utils.isNode
-    ? globalThis.Buffer.allocUnsafe(poolSize)
-    : new Uint8Array(new ArrayBuffer(poolSize))
-  poolOffset = 0
-}
-
-function alignPool() {
-  // Ensure aligned slices
-  if (poolOffset & 0x7) {
-    poolOffset |= 0x7
-    poolOffset++
-  }
-}
-
-function writeString(dst, str, offset) {
-  if (utils.isNode) {
-    return dst.write(str, offset)
-  } else {
-    const res = poolEncoder.encodeInto(str, new Uint8Array(dst.buffer, offset))
-    return res.written
-  }
-}
+const SEP = C.MESSAGE_PART_SEPERATOR
 
 export function getMsg(topic, action, data) {
   if (data && !(data instanceof Array)) {
     throw new Error('data must be an array')
   }
 
-  if (!poolBuffer || poolOffset + maxMessageSize > poolSize) {
-    reallocPool()
-  } else {
-    alignPool()
-  }
-
-  const start = poolOffset
-
-  poolBuffer[poolOffset++] = topic.charCodeAt(0)
-  poolBuffer[poolOffset++] = 31
-  for (let n = 0; n < action.length; n++) {
-    poolBuffer[poolOffset++] = action.charCodeAt(n)
-  }
+  const sendData = [topic, action]
 
   if (data) {
     for (let i = 0; i < data.length; i++) {
-      const type = typeof data[i]
-      if (data[i] == null) {
-        poolBuffer[poolOffset++] = 31
-        poolOffset += 0
-      } else if (type === 'object') {
-        poolBuffer[poolOffset++] = 31
-        poolOffset += writeString(poolBuffer, JSON.stringify(data[i]), poolOffset)
-      } else if (type === 'string') {
-        poolBuffer[poolOffset++] = 31
-        poolOffset += writeString(poolBuffer, data[i], poolOffset)
+      if (typeof data[i] === 'object') {
+        sendData.push(JSON.stringify(data[i]))
       } else {
-        throw new Error('invalid data')
-      }
-
-      if (poolOffset >= poolSize) {
-        throw new Error('message too large')
+        sendData.push(data[i])
       }
     }
   }
 
-  return new Uint8Array(poolBuffer.buffer, start, poolOffset - start)
+  return sendData.join(SEP)
 }
 
 export function typed(value) {

package/src/record/record-handler.js

@@ -95,7 +95,8 @@ class RecordHandler {
     this._options = options
     this._connection = connection
     this._client = client
-    this._records = new Map()
+    this._recordsByName = new Map()
+    this._recordsByKey = new Map()
     this._listeners = new Map()
     this._pruning = new Set()
     this._patching = new Map()
@@ -132,7 +133,7 @@ class RecordHandler {
 
       for (const rec of pruning) {
         rec._$dispose()
-        this._records.delete(rec.name)
+        this._recordsByName.delete(rec.name)
       }
 
       this._stats.pruning -= pruning.size
@@ -215,13 +216,14 @@ class RecordHandler {
       `invalid name ${name}`,
     )
 
-    let record = this._records.get(name)
+    let record = this._recordsByName.get(name)
 
     if (!record) {
       record = new Record(name, this)
       this._stats.records += 1
       this._stats.created += 1
-      this._records.set(name, record)
+      this._recordsByName.set(record.name, record)
+      this._recordsByKey.set(record.name, record)
     }
 
     return record.ref()
@@ -617,11 +619,11 @@ class RecordHandler {
   }
 
   _$handle(message) {
-    let name
+    let key
     if (message.action === C.ACTIONS.ERROR) {
-      name = message.data[1]
+      key = message.data[1]
     } else {
-      name = message.data[0]
+      key = message.data[0]
     }
 
     if (message.action === C.ACTIONS.SYNC) {
@@ -629,12 +631,12 @@ class RecordHandler {
       return true
     }
 
-    const listener = this._listeners.get(name)
+    const listener = this._listeners.get(key)
     if (listener && listener._$onMessage(message)) {
       return true
     }
 
-    const record = this._records.get(name)
+    const record = this._recordsByKey.get(key)
     if (record && record._$onMessage(message)) {
       return true
     }
@@ -647,7 +649,7 @@ class RecordHandler {
       listener._$onConnectionStateChange(connected)
     }
 
-    for (const record of this._records.values()) {
+    for (const record of this._recordsByName.values()) {
       record._$onConnectionStateChange(connected)
     }
 

package/src/record/record.js

@@ -15,6 +15,7 @@ class Record {
 
     this._handler = handler
     this._name = name
+    this._key = utils.h64ToString(name)
     this._version = ''
     this._data = jsonPath.EMPTY
     this._state = C.RECORD_STATE.VOID
@@ -24,7 +25,15 @@ class Record {
 
     /** @type Map? */ this._updating = null
     /** @type Array? */ this._patching = null
-    this._subscribed = connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, [this._name])
+    this._subscribed = connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, [
+      this._key,
+      this._name,
+    ])
+  }
+
+  /** @type { string} */
+  get key() {
+    return this._key
   }
 
   /** @type {string} */
@@ -62,7 +71,8 @@ class Record {
     if (this._refs === 1) {
       this._handler._onPruning(this, false)
       this._subscribed =
-        this._subscribed || connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, [this._name])
+        this._subscribed ||
+        connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, [this._key, this._name])
     }
     return this
   }
@@ -324,7 +334,8 @@ class Record {
 
     if (connected) {
       this._subscribed =
-        this._refs > 0 && connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, [this._name])
+        this._refs > 0 &&
+        connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SUBSCRIBE, [this._key, this._name])
 
       if (this._updating) {
         for (const update of this._updating.values()) {
@@ -349,7 +360,7 @@ class Record {
     invariant(!this._updating, 'must not have updates')
 
     if (this._subscribed) {
-      connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UNSUBSCRIBE, [this._name])
+      connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UNSUBSCRIBE, [this._key])
       this._subscribed = false
     }
 
@@ -371,7 +382,7 @@ class Record {
     const prevVersion = this._version
     const nextVersion = this._makeVersion(parseInt(prevVersion) + 1)
 
-    const update = [this._name, nextVersion, jsonPath.stringify(nextData), prevVersion]
+    const update = [this._key, nextVersion, jsonPath.stringify(nextData), prevVersion]
 
     if (!this._updating) {
       this._onUpdating(true)

package/src/utils/multicast-listener.js

@@ -1,6 +1,176 @@
 import * as rxjs from 'rxjs'
 import * as C from '../constants/constants.js'
 import { h64ToString } from '../utils/utils.js'
+import * as timers from '../utils/timers.js'
+
+class Provider {
+  #sending = false
+  #accepted = false
+  #value$ = null
+  #name
+  #key
+  #version
+  #timeout
+  #valueSubscription
+  #patternSubscription
+  #observer
+  #listener
+
+  constructor(name, listener) {
+    this.#name = name
+    this.#key = h64ToString(name)
+    this.#listener = listener
+    this.#observer = {
+      next: (value) => {
+        if (value == null) {
+          this.next(null) // TODO (fix): This is weird...
+          return
+        }
+
+        if (this.#listener._topic === C.TOPIC.EVENT) {
+          this.#listener._handler.emit(this.#name, value)
+        } else if (this.#listener._topic === C.TOPIC.RECORD) {
+          if (typeof value !== 'object' && typeof value !== 'string') {
+            this.#listener._error(this.#name, 'invalid value')
+            return
+          }
+
+          const body = typeof value !== 'string' ? this.#listener._stringify(value) : value
+          const hash = h64ToString(body)
+          const version = `INF-${hash}`
+
+          if (this.#version !== version) {
+            this.#version = version
+            this.#listener._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, [
+              this.#key,
+              version,
+              body,
+            ])
+          }
+        }
+      },
+      error: (err) => {
+        this.error(err)
+      },
+    }
+
+    this.#start()
+  }
+
+  dispose() {
+    this.#stop()
+  }
+
+  accept() {
+    if (!this.#value$) {
+      return
+    }
+
+    if (this.#valueSubscription) {
+      this.#listener._error(this.#name, 'invalid accept: listener started')
+    } else {
+      // TODO (fix): provider.version = message.data[2]
+      this.#valueSubscription = this.#value$.subscribe(this.#observer)
+    }
+  }
+
+  reject() {
+    this.#listener._error(this.#name, 'invalid reject: not implemented')
+  }
+
+  next(value$) {
+    if (!value$) {
+      value$ = null
+    } else if (typeof value$.subscribe !== 'function') {
+      value$ = rxjs.of(value$) // Compat for recursive with value
+    }
+
+    if (Boolean(this.#value$) !== Boolean(value$) && !this.#sending) {
+      this.#sending = true
+      // TODO (fix): Why async?
+      queueMicrotask(() => {
+        this.#sending = false
+
+        if (!this.#patternSubscription) {
+          return
+        }
+
+        const accepted = Boolean(this.#value$)
+        if (this.#accepted === accepted) {
+          return
+        }
+
+        this.#listener._connection.sendMsg(
+          this.#listener._topic,
+          accepted ? C.ACTIONS.LISTEN_ACCEPT : C.ACTIONS.LISTEN_REJECT,
+          [this.#listener._pattern, this.#key],
+        )
+
+        this.#version = null
+        this.#accepted = accepted
+      })
+    }
+
+    this.#value$ = value$
+
+    if (this.#valueSubscription) {
+      this.#valueSubscription.unsubscribe()
+      this.#valueSubscription = this.#value$?.subscribe(this.#observer)
+    }
+  }
+
+  error(err) {
+    this.#stop()
+    // TODO (feat): backoff retryCount * delay?
+    // TODO (feat): backoff option?
+    this.#timeout = timers.setTimeout(
+      (provider) => {
+        provider.start()
+      },
+      10e3,
+      this,
+    )
+    this.#listener._error(this.#name, err)
+  }
+
+  #start() {
+    try {
+      const ret$ = this.#listener._callback(this.#name)
+      if (this.#listener._recursive && typeof ret$?.subscribe === 'function') {
+        this.patternSubscription = ret$.subscribe(this)
+      } else {
+        this.patternSubscription = rxjs.of(ret$).subscribe(this)
+      }
+    } catch (err) {
+      this.#listener._error(this.#name, err)
+    }
+  }
+
+  #stop() {
+    if (this.#listener.connected && this.#accepted) {
+      this.#listener._connection.sendMsg(this.#listener._topic, C.ACTIONS.LISTEN_REJECT, [
+        this.#listener._pattern,
+        this.#key,
+      ])
+    }
+
+    this.#value$ = null
+    this.#version = null
+    this.#accepted = false
+    this.#sending = false
+
+    if (this.#timeout) {
+      timers.clearTimeout(this.#timeout)
+      this.#timeout = null
+    }
+
+    this.#patternSubscription?.unsubscribe()
+    this.#patternSubscription = null
+
+    this.#valueSubscription?.unsubscribe()
+    this.#valueSubscription = null
+  }
+}
 
 export default class Listener {
   constructor(topic, pattern, callback, handler, { recursive = false, stringify = null } = {}) {
@@ -51,158 +221,20 @@ export default class Listener {
     if (message.action === C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND) {
       if (this._subscriptions.has(name)) {
         this._error(name, 'invalid add: listener exists')
-        return
-      }
-
-      // TODO (refactor): Move to class
-      const provider = {
-        name,
-        value$: null,
-        sending: false,
-        accepted: false,
-        version: null,
-        timeout: null,
-        patternSubscription: null,
-        valueSubscription: null,
-      }
-      provider.stop = () => {
-        if (this.connected && provider.accepted) {
-          this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [
-            this._pattern,
-            provider.name,
-          ])
-        }
-
-        provider.value$ = null
-        provider.version = null
-        provider.accepted = false
-        provider.sending = false
-
-        clearTimeout(provider.timeout)
-        provider.timeout = null
-
-        provider.patternSubscription?.unsubscribe()
-        provider.patternSubscription = null
-
-        provider.valueSubscription?.unsubscribe()
-        provider.valueSubscription = null
-      }
-      provider.send = () => {
-        provider.sending = false
-
-        if (!provider.patternSubscription) {
-          return
-        }
-
-        const accepted = Boolean(provider.value$)
-        if (provider.accepted === accepted) {
-          return
-        }
-
-        this._connection.sendMsg(
-          this._topic,
-          accepted ? C.ACTIONS.LISTEN_ACCEPT : C.ACTIONS.LISTEN_REJECT,
-          [this._pattern, provider.name],
-        )
-
-        provider.version = null
-        provider.accepted = accepted
-      }
-      provider.next = (value$) => {
-        if (!value$) {
-          value$ = null
-        } else if (typeof value$.subscribe !== 'function') {
-          value$ = rxjs.of(value$) // Compat for recursive with value
-        }
-
-        if (Boolean(provider.value$) !== Boolean(value$) && !provider.sending) {
-          provider.sending = true
-          queueMicrotask(provider.send)
-        }
-
-        provider.value$ = value$
-
-        if (provider.valueSubscription) {
-          provider.valueSubscription.unsubscribe()
-          provider.valueSubscription = provider.value$?.subscribe(provider.observer)
-        }
-      }
-      provider.error = (err) => {
-        provider.stop()
-        // TODO (feat): backoff retryCount * delay?
-        // TODO (feat): backoff option?
-        provider.timeout = setTimeout(() => {
-          provider.start()
-        }, 10e3)
-        this._error(provider.name, err)
-      }
-      provider.observer = {
-        next: (value) => {
-          if (value == null) {
-            provider.next(null) // TODO (fix): This is weird...
-            return
-          }
-
-          if (this._topic === C.TOPIC.EVENT) {
-            this._handler.emit(provider.name, value)
-          } else if (this._topic === C.TOPIC.RECORD) {
-            if (typeof value !== 'object' && typeof value !== 'string') {
-              this._error(provider.name, 'invalid value')
-              return
-            }
-
-            const body = typeof value !== 'string' ? this._stringify(value) : value
-            const hash = h64ToString(body)
-            const version = `INF-${hash}`
-
-            if (provider.version !== version) {
-              provider.version = version
-              this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, [
-                provider.name,
-                version,
-                body,
-              ])
-            }
-          }
-        },
-        error: provider.error,
-      }
-      provider.start = () => {
-        try {
-          const ret$ = this._callback(name)
-          if (this._recursive && typeof ret$?.subscribe === 'function') {
-            provider.patternSubscription = ret$.subscribe(provider)
-          } else {
-            provider.patternSubscription = rxjs.of(ret$).subscribe(provider)
-          }
-        } catch (err) {
-          this._error(provider.name, err)
-        }
-      }
-
-      provider.start()
-
-      this._subscriptions.set(provider.name, provider)
-    } else if (message.action === C.ACTIONS.LISTEN_ACCEPT) {
-      const provider = this._subscriptions.get(name)
-      if (!provider?.value$) {
-        return
-      }
-
-      if (provider.valueSubscription) {
-        this._error(name, 'invalid accept: listener started')
       } else {
-        // TODO (fix): provider.version = message.data[2]
-        provider.valueSubscription = provider.value$.subscribe(provider.observer)
+        this._subscriptions.set(name, new Provider(name, this))
       }
+    } else if (message.action === C.ACTIONS.LISTEN_ACCEPT) {
+      this._subscriptions.get(name)?.accept()
+    } else if (message.action === C.ACTIONS.LISTEN_REJECT) {
+      this._subscriptions.get(name)?.reject()
     } else if (message.action === C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_REMOVED) {
       const provider = this._subscriptions.get(name)
-
-      if (!provider) {
-        this._error(name, 'invalid remove: listener missing')
+      if (provider) {
+        provider.dispose()
+        this._subscriptions.delete(name)
       } else {
-        provider.stop()
-        this._subscriptions.delete(provider.name)
+        this._error(name, 'invalid remove: listener missing')
       }
     } else {
       return false

package/src/utils/unicast-listener.js

@@ -1,9 +1,19 @@
-import * as rxjs from 'rxjs'
 import * as C from '../constants/constants.js'
 import { h64ToString } from '../utils/utils.js'
 
-const PIPE = rxjs.pipe(
-  rxjs.map((value) => {
+class Observer {
+  #name
+  #key
+  #listener
+  #version = ''
+
+  constructor(name, listener) {
+    this.#name = name
+    this.#key = h64ToString(name)
+    this.#listener = listener
+  }
+
+  next(value) {
     let data
     if (value && typeof value === 'string') {
       if (value.charAt(0) !== '{' && value.charAt(0) !== '[') {
@@ -16,10 +26,34 @@ const PIPE = rxjs.pipe(
       throw new Error(`invalid value: ${value}`)
     }
 
-    return data
-  }),
-  rxjs.distinctUntilChanged(),
-)
+    const version = data ? `INF-${h64ToString(data)}` : ''
+    if (this.#version === version) {
+      return
+    }
+
+    if (version) {
+      this.#listener._connection.sendMsg(this.#listener._topic, C.ACTIONS.UPDATE, [
+        this.#key,
+        version,
+        data,
+      ])
+    } else {
+      this.#listener._connection.sendMsg(this.#listener._topic, C.ACTIONS.LISTEN_REJECT, [
+        this.#listener._pattern,
+        this.#key,
+      ])
+    }
+
+    this.#version = version
+  }
+  error(err) {
+    this.#listener._error(this.#name, err)
+    this.#listener._connection.sendMsg(this.#listener._topic, C.ACTIONS.LISTEN_REJECT, [
+      this.#listener._pattern,
+      this.#key,
+    ])
+  }
+}
 
 export default class Listener {
   constructor(topic, pattern, callback, handler, opts) {
@@ -65,28 +99,11 @@ export default class Listener {
       try {
         value$ = this._callback(name)
       } catch (err) {
-        value$ = rxjs.throwError(() => err)
+        this._error(name, err)
       }
 
       if (value$) {
-        const subscription = value$.pipe(PIPE).subscribe({
-          next: (data) => {
-            if (data == null) {
-              this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [this._pattern, name])
-              this._subscriptions.delete(name)
-              subscription.unsubscribe()
-            } else {
-              const version = `INF-${h64ToString(data)}`
-              this._connection.sendMsg(this._topic, C.ACTIONS.UPDATE, [name, version, data])
-            }
-          },
-          error: (err) => {
-            this._error(name, err)
-            this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [this._pattern, name])
-            this._subscriptions.delete(name)
-          },
-        })
-        this._subscriptions.set(name, subscription)
+        this._subscriptions.set(name, value$.subscribe(new Observer(name, this)))
       } else {
         this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [this._pattern, name])
       }

package/src/utils/utils.js

@@ -177,10 +177,7 @@ export function removeAbortListener(signal, handler) {
   }
 }
 
-// This is a hack to avoid top-level await
-// const HASHER = await xxhash()
-let HASHER
-xxhash().then((hasher) => (HASHER = hasher))
+const HASHER = await xxhash()
 
 export function h64ToString(str) {
   return HASHER.h64ToString(str)