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

package/src/utils/unicast-listener.js

@@ -1,59 +1,30 @@
+import * as rxjs from 'rxjs'
 import * as C from '../constants/constants.js'
-import { h64ToString } from '../utils/utils.js'
-
-class Observer {
-  #name
-  #key
-  #listener
-  #version = ''
-
-  constructor(name, listener) {
-    this.#name = name
-    this.#key = h64ToString(name)
-    this.#listener = listener
-  }
+import { h64ToString, findBigIntPaths } from '../utils/utils.js'
 
-  next(value) {
-    let data
-    if (value && typeof value === 'string') {
+const PIPE = rxjs.pipe(
+  rxjs.map((value) => {
+    if (typeof value === 'string') {
       if (value.charAt(0) !== '{' && value.charAt(0) !== '[') {
         throw new Error(`invalid value: ${value}`)
       }
-      data = value
-    } else if (value && typeof value === 'object') {
-      data = JSON.stringify(value)
-    } else if (data != null) {
-      throw new Error(`invalid value: ${value}`)
-    }
-
-    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,
-      ])
+      return value
+    } else if (value != null && typeof value === 'object') {
+      try {
+        return JSON.stringify(value)
+      } catch (err) {
+        const bigIntPaths = /BigInt/.test(err.message) ? findBigIntPaths(value) : undefined
+        throw Object.assign(new Error(`invalid value: ${value}`), {
+          cause: err,
+          data: { bigIntPaths },
+        })
+      }
     } else {
-      this.#listener._connection.sendMsg(this.#listener._topic, C.ACTIONS.LISTEN_REJECT, [
-        this.#listener._pattern,
-        this.#key,
-      ])
+      throw new Error(`invalid value: ${value}`)
     }
-
-    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,
-    ])
-  }
-}
+  }),
+  rxjs.distinctUntilChanged(),
+)
 
 export default class Listener {
   constructor(topic, pattern, callback, handler, opts) {
@@ -99,11 +70,24 @@ export default class Listener {
       try {
         value$ = this._callback(name)
       } catch (err) {
-        this._error(name, err)
+        value$ = rxjs.throwError(() => err)
       }
 
       if (value$) {
-        this._subscriptions.set(name, value$.subscribe(new Observer(name, this)))
+        const subscription = value$.pipe(PIPE).subscribe({
+          next: (data) => {
+            const version = `INF-${h64ToString(data)}`
+            this._connection.sendMsg(this._topic, C.ACTIONS.UPDATE, [name, version, data])
+          },
+          error: (err) => {
+            this._error(name, err)
+
+            this._subscriptions.delete(name)
+            this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [this._pattern, name])
+          },
+        })
+
+        this._subscriptions.set(name, subscription)
       } else {
         this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [this._pattern, name])
       }

package/src/utils/utils.js

@@ -177,8 +177,27 @@ export function removeAbortListener(signal, handler) {
   }
 }
 
-const HASHER = await xxhash()
+// This is a hack to avoid top-level await
+// const HASHER = await xxhash()
+let HASHER
+xxhash().then((hasher) => (HASHER = hasher))
 
 export function h64ToString(str) {
   return HASHER.h64ToString(str)
 }
+
+export function findBigIntPaths(obj, path = "") {
+  const paths = []
+
+  if (typeof obj === "bigint") {
+    return [path]
+  }
+
+  if (typeof obj === "object" && obj !== null) {
+    for (const key of Object.keys(obj)) {
+      paths.push(...findBigIntPaths(obj[key], path ? `${path}.${key}` : key))
+    }
+  }
+
+  return paths
+}