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

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,252 +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(
-                  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()
-  }
-}