@nxtedition/deepstream.io-client-js 32.0.27 → 32.0.28

package/package.json

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

package/src/event/event-handler.js

@@ -157,6 +157,10 @@ EventHandler.prototype._$handle = function (message) {
 }
 
 EventHandler.prototype._onConnectionStateChange = function (connected) {
+  for (const listener of this._listeners.values()) {
+    listener._$onConnectionStateChange(connected)
+  }
+
   if (connected) {
     for (const eventName of this._emitter.eventNames()) {
       this._connection.sendMsg(C.TOPIC.EVENT, C.ACTIONS.SUBSCRIBE, [eventName])

package/src/record/record-handler.js

@@ -604,19 +604,19 @@ class RecordHandler {
     }
 
     if (!Number.isInteger(state) || state < 0) {
-      throw new Error('invalid argument: state')
+      throw new Error(`invalid argument "state": ${state}`)
     }
 
     if (!Number.isInteger(timeout) || timeout < 0) {
-      throw new Error('invalid argument: timeout')
+      throw new Error(`invalid argument "timeout": ${timeout}`)
     }
 
     if (typeof dataOnly !== 'boolean') {
-      throw new Error('invalid argument: dataOnly')
+      throw new Error(`invalid argument "dataOnly": ${dataOnly}`)
     }
 
     if (typeof sync !== 'boolean') {
-      throw new Error('invalid argument: sync')
+      throw new Error(`invalid argument "sync": ${sync}`)
     }
 
     return new rxjs.Observable((subscriber) => {

package/src/utils/legacy-listener.js

@@ -38,12 +38,12 @@ export default class Listener {
   _$onMessage(message) {
     if (!this.connected) {
       this._client._$onError(
-        C.TOPIC.RECORD,
+        this._topic,
         C.EVENT.NOT_CONNECTED,
         new Error('received message while not connected'),
         message,
       )
-      return
+      return true
     }
 
     const name = message.data[1]
@@ -192,13 +192,15 @@ export default class Listener {
             provider.patternSubscription = rxjs.of(ret$).subscribe(provider)
           }
         } catch (err) {
+          provider.stop()
+          this._subscriptions.delete(provider.name)
           this._error(provider.name, err)
         }
       }
 
-      provider.start()
-
       this._subscriptions.set(provider.name, provider)
+
+      provider.start()
     } else if (message.action === C.ACTIONS.LISTEN_ACCEPT) {
       const provider = this._subscriptions.get(name)
       if (!provider?.value$) {

package/src/utils/unicast-listener.js

@@ -55,6 +55,8 @@ export default class Listener {
 
   _$destroy() {
     this._reset()
+
+    this._connection.sendMsg(this._topic, C.ACTIONS.UNLISTEN, [this._pattern])
   }
 
   _$onMessage(message) {
@@ -77,12 +79,14 @@ export default class Listener {
       }
 
       if (value$) {
+        let errored = false
         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) => {
+            errored = true
             this._error(name, err)
 
             this._subscriptions.delete(name)
@@ -90,7 +94,9 @@ export default class Listener {
           },
         })
 
-        this._subscriptions.set(name, subscription)
+        if (!errored) {
+          this._subscriptions.set(name, subscription)
+        }
       } else {
         this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [this._pattern, name])
       }
@@ -129,7 +135,5 @@ export default class Listener {
       subscription.unsubscribe()
     }
     this._subscriptions.clear()
-
-    this._connection.sendMsg(this._topic, C.ACTIONS.UNLISTEN, [this._pattern])
   }
 }

package/test/legacy-listener.test.js

@@ -0,0 +1,450 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import * as C from '../src/constants/constants.js'
+
+// Minimal mock helpers
+function createMockConnection(connected = true) {
+  return {
+    connected,
+    messages: [],
+    sendMsg(topic, action, data) {
+      this.messages.push({ topic, action, data })
+    },
+  }
+}
+
+function createMockClient() {
+  return {
+    errors: [],
+    _$onError(topic, event, err, data) {
+      this.errors.push({ topic, event, err, data })
+    },
+  }
+}
+
+function createMockHandler(connection, client) {
+  return {
+    _client: client,
+    _connection: connection,
+  }
+}
+
+function msg(action, data) {
+  return { action, data }
+}
+
+// We can't import the Listener directly because it depends on xxhash-wasm (top-level await).
+// Instead, we dynamically import after setting up mocks.
+let Listener
+
+describe('LegacyListener', async () => {
+  Listener = (await import('../src/utils/legacy-listener.js')).default
+
+  describe('constructor', () => {
+    it('sends LISTEN on construction when connected', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+
+      assert.equal(connection.messages.length, 1)
+      assert.deepEqual(connection.messages[0], {
+        topic: C.TOPIC.RECORD,
+        action: C.ACTIONS.LISTEN,
+        data: ['test/.*'],
+      })
+    })
+
+    it('does not send LISTEN when not connected', () => {
+      const connection = createMockConnection(false)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+
+      assert.equal(connection.messages.length, 0)
+    })
+  })
+
+  describe('_$onMessage - not connected', () => {
+    it('returns true and reports error with correct topic', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.EVENT, 'test/.*', () => null, handler)
+
+      // Simulate disconnect without calling _$onConnectionStateChange
+      connection.connected = false
+
+      const result = listener._$onMessage(
+        msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']),
+      )
+
+      assert.equal(result, true)
+      assert.equal(client.errors.length, 1)
+      assert.equal(client.errors[0].topic, C.TOPIC.EVENT) // Bug 1: was hardcoded to RECORD
+      assert.equal(client.errors[0].event, C.EVENT.NOT_CONNECTED)
+    })
+  })
+
+  describe('_$onMessage - SUBSCRIPTION_FOR_PATTERN_FOUND', () => {
+    it('creates a provider and sends LISTEN_ACCEPT via microtask', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const { of } = await import('rxjs')
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => of({ key: 'value' }), handler)
+      connection.messages.length = 0
+
+      const result = listener._$onMessage(
+        msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']),
+      )
+
+      assert.equal(result, true)
+      assert.equal(listener.stats.subscriptions, 1)
+
+      // Wait for microtask to fire provider.send()
+      await new Promise((r) => queueMicrotask(r))
+
+      const acceptMsg = connection.messages.find((m) => m.action === C.ACTIONS.LISTEN_ACCEPT)
+      assert.ok(acceptMsg, 'should send LISTEN_ACCEPT')
+      assert.deepEqual(acceptMsg.data, ['test/.*', 'test/1'])
+    })
+
+    it('rejects duplicate subscription names', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const listener = new Listener(
+        C.TOPIC.RECORD,
+        'test/.*',
+        () => rxjs.of({ key: 'val' }),
+        handler,
+      )
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+
+      assert.equal(client.errors.length, 1)
+      assert.ok(String(client.errors[0].err).includes('invalid add'))
+    })
+
+    it('cleans up provider when callback throws (Bug 3)', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(
+        C.TOPIC.RECORD,
+        'test/.*',
+        () => {
+          throw new Error('callback failed')
+        },
+        handler,
+      )
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+
+      // Provider should be removed from map after callback throws
+      assert.equal(listener.stats.subscriptions, 0)
+      assert.equal(client.errors.length, 1)
+    })
+
+    it('sends LISTEN_REJECT when callback returns null', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+
+      // rxjs.of(null) emits null synchronously, provider.next(null) sets value$ to null
+      // provider.send is queued via microtask — wait for it, then another for delivery
+      await new Promise((r) => queueMicrotask(r))
+      await new Promise((r) => queueMicrotask(r))
+
+      // With null callback, value$ stays null, so accepted=false matches initial accepted=false
+      // The provider never sends ACCEPT in the first place, so no REJECT is sent either.
+      // This is correct behavior: null means "don't provide", so we don't accept or reject.
+      assert.equal(listener.stats.subscriptions, 1)
+    })
+  })
+
+  describe('_$onMessage - SUBSCRIPTION_FOR_PATTERN_REMOVED', () => {
+    it('stops and removes the provider', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+      assert.equal(listener.stats.subscriptions, 1)
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_REMOVED, ['test/.*', 'test/1']))
+      assert.equal(listener.stats.subscriptions, 0)
+    })
+
+    it('errors on removal of unknown subscription', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+
+      listener._$onMessage(
+        msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_REMOVED, ['test/.*', 'test/unknown']),
+      )
+
+      assert.equal(client.errors.length, 1)
+      assert.ok(String(client.errors[0].err).includes('invalid remove'))
+    })
+  })
+
+  describe('_$onMessage - LISTEN_ACCEPT', () => {
+    it('starts value subscription when provider has value$', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const value$ = new rxjs.BehaviorSubject({ data: 'hello' })
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => value$, handler)
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+
+      // Wait for microtask to send LISTEN_ACCEPT
+      await new Promise((r) => queueMicrotask(r))
+
+      // Server sends back LISTEN_ACCEPT
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      // Should have sent an UPDATE with the value
+      const updateMsg = connection.messages.find((m) => m.action === C.ACTIONS.UPDATE)
+      assert.ok(updateMsg, 'should send UPDATE after LISTEN_ACCEPT')
+      assert.equal(updateMsg.data[0], 'test/1')
+    })
+
+    it('ignores LISTEN_ACCEPT when provider has no value$', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      // No error, no crash
+      assert.equal(client.errors.length, 0)
+    })
+  })
+
+  describe('_$onMessage - unknown action', () => {
+    it('returns false for unrecognized actions', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+
+      const result = listener._$onMessage(msg(C.ACTIONS.UPDATE, ['test/.*', 'test/1']))
+      assert.equal(result, false)
+    })
+  })
+
+  describe('_$onConnectionStateChange', () => {
+    it('re-sends LISTEN on reconnect', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+      connection.messages.length = 0
+
+      // Simulate disconnect
+      connection.connected = false
+      listener._$onConnectionStateChange()
+
+      // Simulate reconnect
+      connection.connected = true
+      listener._$onConnectionStateChange()
+
+      assert.equal(connection.messages.length, 1)
+      assert.deepEqual(connection.messages[0], {
+        topic: C.TOPIC.RECORD,
+        action: C.ACTIONS.LISTEN,
+        data: ['test/.*'],
+      })
+    })
+
+    it('clears all subscriptions on disconnect', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+      assert.equal(listener.stats.subscriptions, 1)
+
+      connection.connected = false
+      listener._$onConnectionStateChange()
+
+      assert.equal(listener.stats.subscriptions, 0)
+    })
+  })
+
+  describe('_$destroy', () => {
+    it('sends UNLISTEN and cleans up when connected', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+      connection.messages.length = 0
+
+      listener._$destroy()
+
+      assert.equal(listener.stats.subscriptions, 0)
+      const unlistenMsg = connection.messages.find((m) => m.action === C.ACTIONS.UNLISTEN)
+      assert.ok(unlistenMsg, 'should send UNLISTEN')
+    })
+
+    it('does not send UNLISTEN when not connected', () => {
+      const connection = createMockConnection(false)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler)
+
+      listener._$destroy()
+
+      const unlistenMsg = connection.messages.find((m) => m.action === C.ACTIONS.UNLISTEN)
+      assert.equal(unlistenMsg, undefined)
+    })
+  })
+
+  describe('provider.observer - record values', () => {
+    it('deduplicates identical values by hash', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const subject = new rxjs.BehaviorSubject({ key: 'value' })
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => subject, handler)
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+      await new Promise((r) => queueMicrotask(r))
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      const updateCount = connection.messages.filter((m) => m.action === C.ACTIONS.UPDATE).length
+
+      // Emit same value again
+      subject.next({ key: 'value' })
+
+      const updateCount2 = connection.messages.filter((m) => m.action === C.ACTIONS.UPDATE).length
+      assert.equal(updateCount2, updateCount, 'should not send duplicate UPDATE for same hash')
+    })
+
+    it('handles null values from observer by calling provider.next(null)', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const subject = new rxjs.Subject()
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => subject, handler)
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+      await new Promise((r) => queueMicrotask(r))
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      // Emit null - should trigger provider.next(null) which rejects
+      subject.next(null)
+      await new Promise((r) => queueMicrotask(r))
+
+      const rejectMsg = connection.messages.find((m) => m.action === C.ACTIONS.LISTEN_REJECT)
+      assert.ok(rejectMsg, 'should send LISTEN_REJECT when value becomes null')
+    })
+
+    it('errors on invalid non-object non-string values', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const subject = new rxjs.Subject()
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => subject, handler)
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+      await new Promise((r) => queueMicrotask(r))
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      subject.next(42)
+
+      assert.equal(client.errors.length, 1)
+      assert.ok(String(client.errors[0].err).includes('invalid value'))
+    })
+  })
+
+  describe('provider.error - retry behavior', () => {
+    it('retries after error with timeout', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      let callCount = 0
+      const listener = new Listener(
+        C.TOPIC.RECORD,
+        'test/.*',
+        () => {
+          callCount++
+          if (callCount === 1) {
+            return rxjs.throwError(() => new Error('temporary'))
+          }
+          return rxjs.of({ ok: true })
+        },
+        handler,
+        { recursive: true },
+      )
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND, ['test/.*', 'test/1']))
+
+      assert.equal(callCount, 1)
+      assert.equal(client.errors.length, 1)
+
+      // The retry timeout is 10 seconds, we don't want to actually wait
+      // Just verify the provider is still in the map (will be retried)
+      assert.equal(listener.stats.subscriptions, 1)
+    })
+  })
+})

package/test/unicast-listener.test.js

@@ -0,0 +1,366 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import * as C from '../src/constants/constants.js'
+
+function createMockConnection(connected = true) {
+  return {
+    connected,
+    messages: [],
+    sendMsg(topic, action, data) {
+      this.messages.push({ topic, action, data })
+    },
+  }
+}
+
+function createMockClient() {
+  return {
+    errors: [],
+    _$onError(topic, event, err, data) {
+      this.errors.push({ topic, event, err, data })
+    },
+  }
+}
+
+function createMockHandler(connection, client) {
+  return {
+    _client: client,
+    _connection: connection,
+  }
+}
+
+function msg(action, data) {
+  return { action, data }
+}
+
+let Listener
+
+describe('UnicastListener', async () => {
+  Listener = (await import('../src/utils/unicast-listener.js')).default
+
+  describe('constructor', () => {
+    it('sends LISTEN with U flag on construction', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler, {})
+
+      assert.equal(connection.messages.length, 1)
+      assert.deepEqual(connection.messages[0], {
+        topic: C.TOPIC.RECORD,
+        action: C.ACTIONS.LISTEN,
+        data: ['test/.*', 'U'],
+      })
+    })
+
+    it('throws on recursive option', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      assert.throws(
+        () => new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler, { recursive: true }),
+        /invalid argument: recursive/,
+      )
+    })
+
+    it('throws on stringify option', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      assert.throws(
+        () =>
+          new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler, {
+            stringify: JSON.stringify,
+          }),
+        /invalid argument: stringify/,
+      )
+    })
+  })
+
+  describe('_$onMessage - LISTEN_ACCEPT', () => {
+    it('calls callback and subscribes when value$ returned', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const value$ = new rxjs.BehaviorSubject('{"key":"value"}')
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => value$, handler, {})
+      connection.messages.length = 0
+
+      const result = listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      assert.equal(result, true)
+      assert.equal(listener.stats.subscriptions, 1)
+
+      const updateMsg = connection.messages.find((m) => m.action === C.ACTIONS.UPDATE)
+      assert.ok(updateMsg, 'should send UPDATE')
+      assert.equal(updateMsg.data[0], 'test/1')
+    })
+
+    it('sends LISTEN_REJECT when callback returns falsy', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler, {})
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      assert.equal(listener.stats.subscriptions, 0)
+      const rejectMsg = connection.messages.find((m) => m.action === C.ACTIONS.LISTEN_REJECT)
+      assert.ok(rejectMsg, 'should send LISTEN_REJECT')
+    })
+
+    it('wraps callback exceptions in throwError and rejects', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(
+        C.TOPIC.RECORD,
+        'test/.*',
+        () => {
+          throw new Error('callback failed')
+        },
+        handler,
+        {},
+      )
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      // The error is caught and wrapped in rxjs.throwError, which triggers the PIPE error,
+      // which triggers the subscription error handler that sends LISTEN_REJECT
+      assert.equal(client.errors.length, 1)
+      const rejectMsg = connection.messages.find((m) => m.action === C.ACTIONS.LISTEN_REJECT)
+      assert.ok(rejectMsg, 'should send LISTEN_REJECT on error')
+      // subscription is removed by the error handler
+      assert.equal(listener.stats.subscriptions, 0)
+    })
+
+    it('rejects duplicate subscription names', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const listener = new Listener(
+        C.TOPIC.RECORD,
+        'test/.*',
+        () => new rxjs.BehaviorSubject('{"x":1}'),
+        handler,
+        {},
+      )
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      assert.equal(client.errors.length, 1)
+      assert.ok(String(client.errors[0].err).includes('invalid accept'))
+    })
+  })
+
+  describe('_$onMessage - LISTEN_REJECT', () => {
+    it('unsubscribes and removes provider', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const value$ = new rxjs.BehaviorSubject('{"key":"value"}')
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => value$, handler, {})
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+      assert.equal(listener.stats.subscriptions, 1)
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_REJECT, ['test/.*', 'test/1']))
+      assert.equal(listener.stats.subscriptions, 0)
+    })
+
+    it('errors on removal of unknown subscription', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler, {})
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_REJECT, ['test/.*', 'test/unknown']))
+
+      assert.equal(client.errors.length, 1)
+      assert.ok(String(client.errors[0].err).includes('invalid remove'))
+    })
+  })
+
+  describe('_$onMessage - unknown action', () => {
+    it('returns false for unrecognized actions', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler, {})
+
+      const result = listener._$onMessage(msg(C.ACTIONS.UPDATE, ['test/.*', 'test/1']))
+      assert.equal(result, false)
+    })
+  })
+
+  describe('_$onConnectionStateChange', () => {
+    it('re-sends LISTEN on reconnect', () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => null, handler, {})
+      connection.messages.length = 0
+
+      listener._$onConnectionStateChange(false)
+      listener._$onConnectionStateChange(true)
+
+      assert.equal(connection.messages.length, 1)
+      assert.deepEqual(connection.messages[0], {
+        topic: C.TOPIC.RECORD,
+        action: C.ACTIONS.LISTEN,
+        data: ['test/.*', 'U'],
+      })
+    })
+
+    it('clears subscriptions on disconnect without sending UNLISTEN (Bug 5 fix)', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const listener = new Listener(
+        C.TOPIC.RECORD,
+        'test/.*',
+        () => new rxjs.BehaviorSubject('{"x":1}'),
+        handler,
+        {},
+      )
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+      assert.equal(listener.stats.subscriptions, 1)
+
+      connection.messages.length = 0
+      listener._$onConnectionStateChange(false)
+
+      assert.equal(listener.stats.subscriptions, 0)
+      // Should NOT send UNLISTEN on disconnected connection
+      const unlistenMsg = connection.messages.find((m) => m.action === C.ACTIONS.UNLISTEN)
+      assert.equal(unlistenMsg, undefined, 'should not send UNLISTEN when disconnected')
+    })
+  })
+
+  describe('_$destroy', () => {
+    it('sends UNLISTEN and cleans up', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const listener = new Listener(
+        C.TOPIC.RECORD,
+        'test/.*',
+        () => new rxjs.BehaviorSubject('{"x":1}'),
+        handler,
+        {},
+      )
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+      connection.messages.length = 0
+
+      listener._$destroy()
+
+      assert.equal(listener.stats.subscriptions, 0)
+      const unlistenMsg = connection.messages.find((m) => m.action === C.ACTIONS.UNLISTEN)
+      assert.ok(unlistenMsg, 'should send UNLISTEN on destroy')
+    })
+  })
+
+  describe('PIPE - value validation', () => {
+    it('rejects non-JSON strings', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const subject = new rxjs.BehaviorSubject('not-json')
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => subject, handler, {})
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      // Error should have been reported
+      assert.equal(client.errors.length, 1)
+    })
+
+    it('accepts valid JSON strings', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const subject = new rxjs.BehaviorSubject('{"valid": true}')
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => subject, handler, {})
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      assert.equal(client.errors.length, 0)
+      const updateMsg = connection.messages.find((m) => m.action === C.ACTIONS.UPDATE)
+      assert.ok(updateMsg)
+    })
+
+    it('serializes objects to JSON', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const subject = new rxjs.BehaviorSubject({ key: 'value' })
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => subject, handler, {})
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      const updateMsg = connection.messages.find((m) => m.action === C.ACTIONS.UPDATE)
+      assert.ok(updateMsg)
+      assert.equal(updateMsg.data[2], '{"key":"value"}')
+    })
+
+    it('deduplicates identical serialized values', async () => {
+      const connection = createMockConnection(true)
+      const client = createMockClient()
+      const handler = createMockHandler(connection, client)
+      const rxjs = await import('rxjs')
+
+      const subject = new rxjs.BehaviorSubject({ key: 'value' })
+
+      const listener = new Listener(C.TOPIC.RECORD, 'test/.*', () => subject, handler, {})
+      connection.messages.length = 0
+
+      listener._$onMessage(msg(C.ACTIONS.LISTEN_ACCEPT, ['test/.*', 'test/1']))
+
+      const count1 = connection.messages.filter((m) => m.action === C.ACTIONS.UPDATE).length
+
+      // Same value, different object reference
+      subject.next({ key: 'value' })
+
+      const count2 = connection.messages.filter((m) => m.action === C.ACTIONS.UPDATE).length
+      assert.equal(count2, count1, 'should deduplicate identical serialized values')
+    })
+  })
+})

package/src/utils/multicast-listener.js

@@ -1,253 +0,0 @@
-import * as rxjs from 'rxjs'
-import * as C from '../constants/constants.js'
-import { h64ToString, findBigIntPaths } from '../utils/utils.js'
-
-export default class Listener {
-  constructor(topic, pattern, callback, handler, { recursive = false, stringify = null } = {}) {
-    this._topic = topic
-    this._pattern = pattern
-    this._callback = callback
-    this._handler = handler
-    this._client = this._handler._client
-    this._connection = this._handler._connection
-    this._subscriptions = new Map()
-    this._recursive = recursive
-    this._stringify = stringify || JSON.stringify
-
-    this._$onConnectionStateChange()
-  }
-
-  get connected() {
-    return this._connection.connected
-  }
-
-  get stats() {
-    return {
-      subscriptions: this._subscriptions.size,
-    }
-  }
-
-  _$destroy() {
-    this._reset()
-
-    if (this.connected) {
-      this._connection.sendMsg(this._topic, C.ACTIONS.UNLISTEN, [this._pattern])
-    }
-  }
-
-  _$onMessage(message) {
-    if (!this.connected) {
-      this._client._$onError(
-        C.TOPIC.RECORD,
-        C.EVENT.NOT_CONNECTED,
-        new Error('received message while not connected'),
-        message,
-      )
-      return
-    }
-
-    const name = message.data[1]
-
-    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
-            }
-
-            if (typeof value !== 'string') {
-              try {
-                value = this._stringify(value)
-              } catch (err) {
-                const bigIntPaths = /BigInt/.test(err.message) ? findBigIntPaths(value) : undefined
-                this._error(
-                  provider.name,
-                  Object.assign(new Error(`invalid value: ${value}`), {
-                    cause: err,
-                    data: { name: provider.name, bigIntPaths },
-                  }),
-                )
-                return
-              }
-            }
-
-            const body = 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 (pattern:' + this._pattern + ' name:' + name + ')',
-        )
-      } else {
-        // TODO (fix): provider.version = message.data[2]
-        provider.valueSubscription = provider.value$.subscribe(provider.observer)
-      }
-    } 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 (pattern:' + this._pattern + ' name:' + name + ')',
-        )
-      } else {
-        provider.stop()
-        this._subscriptions.delete(provider.name)
-      }
-    } else {
-      return false
-    }
-    return true
-  }
-
-  _$onConnectionStateChange() {
-    if (this.connected) {
-      this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN, [this._pattern])
-    } else {
-      this._reset()
-    }
-  }
-
-  _error(name, err) {
-    this._client._$onError(this._topic, C.EVENT.LISTENER_ERROR, err, [this._pattern, name])
-  }
-
-  _reset() {
-    for (const provider of this._subscriptions.values()) {
-      provider.stop()
-    }
-    this._subscriptions.clear()
-  }
-}