anear-js-api 1.1.3 → 1.1.4

package/lib/utils/RealtimeMessaging.js

@@ -10,18 +10,86 @@ const NotableChannelEvents = ['attached', 'suspended', 'failed']
 class RealtimeMessaging {
   constructor() {
     this.ablyRealtime = null
+    // Prevent accidental duplicate listeners/subscriptions which can happen if
+    // getChannel()/subscribe()/enablePresenceCallbacks() are called more than once
+    // for the same actor+channel pair (e.g. reconnect/re-init scenarios).
+    this._channelStateListenerKeys = new Set()
+    this._presenceListenerKeys = new Set()
+    this._messageListenerKeys = new Set()
+  }
+
+  logAblyStateChange({ scope, name, current, previous, retryIn, reason }) {
+    // Keep normal churn at debug, but surface real problems at info/warn.
+    // Ably `reason` is typically an ErrorInfo with { code, message, statusCode }.
+    const label = name ? `${scope}:${name}` : scope
+    const msg = `[RTM] ${label} state changed ${previous || 'NONE'} → ${current}`
+    const details = { retryIn, reason }
+
+    switch (current) {
+      case 'FAILED':
+        logger.warn(msg, details)
+        break
+      case 'SUSPENDED':
+      case 'DISCONNECTED':
+        logger.info(msg, details)
+        break
+      default:
+        logger.debug(msg, details)
+        break
+    }
   }
 
   initRealtime(appId, actor) {
+    // initRealtime is expected to be called once per process/appId. If it is
+    // called again, close the existing connection to avoid duplicate callbacks.
+    if (this.ablyRealtime) {
+      logger.warn('[RTM] initRealtime called while already initialized; closing previous Ably client')
+      try {
+        this.ablyRealtime.close()
+      } catch (e) {
+        logger.warn('[RTM] error closing previous Ably client', e)
+      }
+      this.ablyRealtime = null
+      this._channelStateListenerKeys.clear()
+      this._presenceListenerKeys.clear()
+      this._messageListenerKeys.clear()
+    }
+
     const clientOptions = this.ablyClientOptions(appId)
 
     logger.debug("[RTM] Ably Client Options", clientOptions)
 
     this.ablyRealtime = new Ably.Realtime(clientOptions)
 
-    this.ablyRealtime.connection.on((stateChange) =>
-      actor.send({ type: stateChange.current.toUpperCase() })
-    )
+    this.ablyRealtime.connection.on((stateChange) => {
+      const type = stateChange.current.toUpperCase()
+      const previous = stateChange.previous ? stateChange.previous.toUpperCase() : null
+      const reason = stateChange.reason
+        ? {
+          code: stateChange.reason.code,
+          message: stateChange.reason.message,
+          statusCode: stateChange.reason.statusCode
+        }
+        : null
+
+      this.logAblyStateChange({
+        scope: 'connection',
+        name: null,
+        current: type,
+        previous,
+        retryIn: stateChange.retryIn,
+        reason
+      })
+      actor.send({
+        type,
+        data: {
+          previous,
+          current: type,
+          retryIn: stateChange.retryIn,
+          reason
+        }
+      })
+    })
     return this
   }
 
@@ -35,10 +103,39 @@ class RealtimeMessaging {
   }
 
   enableCallbacks(channel, actor) {
+    const key = `${actor.id}::${channel.name}::channel_state`
+    if (this._channelStateListenerKeys.has(key)) return
+    this._channelStateListenerKeys.add(key)
+
     const stateChangeCallback = stateChange => {
       const channelState = stateChange.current.toUpperCase()
-      logger.debug(`[RTM] sending machine event: ${channel.name} state changed to ${channelState}`)
-      return actor.send({ type: channelState, data: { channelName: channel.name } })
+      const previous = stateChange.previous ? stateChange.previous.toUpperCase() : null
+      const reason = stateChange.reason
+        ? {
+          code: stateChange.reason.code,
+          message: stateChange.reason.message,
+          statusCode: stateChange.reason.statusCode
+        }
+        : null
+
+      this.logAblyStateChange({
+        scope: 'channel',
+        name: channel.name,
+        current: channelState,
+        previous,
+        retryIn: stateChange.retryIn,
+        reason
+      })
+      return actor.send({
+        type: channelState,
+        data: {
+          channelName: channel.name,
+          previous,
+          current: channelState,
+          resumed: stateChange.resumed,
+          reason
+        }
+      })
     }
 
     logger.debug(`[RTM] enabling ${NotableChannelEvents} on ${channel.name}`)
@@ -50,6 +147,10 @@ class RealtimeMessaging {
     const presenceActionFunc = action => {
       const eventName = `${presencePrefix}_${action.toUpperCase()}` // e.g.  PARTICIPANT_ENTER, PARTICIPANT_LEAVE
 
+      const key = `${actor.id}::${channel.name}::presence::${eventName}`
+      if (this._presenceListenerKeys.has(key)) return
+      this._presenceListenerKeys.add(key)
+
       logger.debug(`[RTM] ${channel.name} subscribing to ${eventName}`)
 
       channel.presence.subscribe(
@@ -113,6 +214,10 @@ class RealtimeMessaging {
 
   subscribe(channel, actor, eventName = null) {
     // Note: subscribing to an Ably channel will implicitly attach()
+    const key = `${actor.id}::${channel.name}::subscribe::${eventName || '*'}`
+    if (this._messageListenerKeys.has(key)) return
+    this._messageListenerKeys.add(key)
+
     const args = []
 
     if (eventName) args.push(eventName)
@@ -165,6 +270,9 @@ class RealtimeMessaging {
   close() {
     this.ablyRealtime && this.ablyRealtime.close()
     this.ablyRealtime = null
+    this._channelStateListenerKeys.clear()
+    this._presenceListenerKeys.clear()
+    this._messageListenerKeys.clear()
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anear-js-api",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Javascript Developer API for Anear Apps",
   "main": "lib/index.js",
   "scripts": {

package/tests/RealtimeMessaging.test.js

@@ -38,6 +38,8 @@ jest.mock('../lib/api/AnearApi', () => ({
 }))
 jest.mock('../lib/utils/Logger', () => ({
   debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
   error: jest.fn(),
 }))
 
@@ -48,6 +50,9 @@ describe('RealtimeMessaging', () => {
     // Reset mocks and the singleton's internal state before each test
     jest.clearAllMocks()
     RealtimeMessaging.ablyRealtime = null
+    RealtimeMessaging._channelStateListenerKeys && RealtimeMessaging._channelStateListenerKeys.clear()
+    RealtimeMessaging._presenceListenerKeys && RealtimeMessaging._presenceListenerKeys.clear()
+    RealtimeMessaging._messageListenerKeys && RealtimeMessaging._messageListenerKeys.clear()
     mockActor = {
       id: 'test-actor',
       send: jest.fn(),
@@ -74,10 +79,10 @@ describe('RealtimeMessaging', () => {
       const stateChangeCallback = mockRealtimeInstance.connection.on.mock.calls[0][0]
 
       stateChangeCallback({ current: 'connected' })
-      expect(mockActor.send).toHaveBeenCalledWith({ type: 'CONNECTED' })
+      expect(mockActor.send).toHaveBeenCalledWith(expect.objectContaining({ type: 'CONNECTED' }))
 
       stateChangeCallback({ current: 'suspended' })
-      expect(mockActor.send).toHaveBeenCalledWith({ type: 'SUSPENDED' })
+      expect(mockActor.send).toHaveBeenCalledWith(expect.objectContaining({ type: 'SUSPENDED' }))
     })
   })
 
@@ -105,10 +110,20 @@ describe('RealtimeMessaging', () => {
       const stateChangeCallback = mockChannel.on.mock.calls[0][1]
 
       stateChangeCallback({ current: 'attached' })
-      expect(mockActor.send).toHaveBeenCalledWith({ type: 'ATTACHED', data: { channelName: 'mock-channel' } })
+      expect(mockActor.send).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'ATTACHED',
+          data: expect.objectContaining({ channelName: 'mock-channel' })
+        })
+      )
 
       stateChangeCallback({ current: 'failed' })
-      expect(mockActor.send).toHaveBeenCalledWith({ type: 'FAILED', data: { channelName: 'mock-channel' } })
+      expect(mockActor.send).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'FAILED',
+          data: expect.objectContaining({ channelName: 'mock-channel' })
+        })
+      )
     })
   })