@mojaloop/central-services-shared 18.25.0 → 18.26.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [18.26.0](https://github.com/mojaloop/central-services-shared/compare/v18.25.0...v18.26.0) (2025-05-13)
+
+
+### Features
+
+* add sharded pubsub support ([#450](https://github.com/mojaloop/central-services-shared/issues/450)) ([d98675c](https://github.com/mojaloop/central-services-shared/commit/d98675c4d403ad835f462affc06cbab55344958d))
+
 ## [18.25.0](https://github.com/mojaloop/central-services-shared/compare/v18.24.0...v18.25.0) (2025-05-13)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-services-shared",
-  "version": "18.25.0",
+  "version": "18.26.0",
   "description": "Shared code for mojaloop central services",
   "license": "Apache-2.0",
   "author": "ModusBox",

package/src/util/redis/pubSub.js

@@ -54,7 +54,7 @@ class PubSub {
   createRedisClient () {
     this.config.lazyConnect ??= true
     return this.isCluster
-      ? new Redis.Cluster(this.config.cluster, this.config)
+      ? new Redis.Cluster(this.config.cluster, { ...this.config, shardedSubscribers: true })
       : new Redis(this.config)
   }
 
@@ -113,7 +113,11 @@ class PubSub {
 
   async publish (channel, message) {
     try {
-      await this.publisherClient.publish(channel, JSON.stringify(message))
+      if (this.isCluster) {
+        await this.publisherClient.spublish(channel, JSON.stringify(message))
+      } else {
+        await this.publisherClient.publish(channel, JSON.stringify(message))
+      }
       this.log.info(`Message published to channel: ${channel}`)
     } catch (err) {
       this.log.error('Error publishing message:', err)
@@ -123,12 +127,21 @@ class PubSub {
 
   async subscribe (channel, callback) {
     try {
-      await this.subscriberClient.subscribe(channel)
-      this.subscriberClient.on('message', (subscribedChannel, message) => {
-        if (subscribedChannel === channel) {
-          callback(JSON.parse(message))
-        }
-      })
+      if (this.isCluster) {
+        await this.subscriberClient.ssubscribe(channel)
+        this.subscriberClient.on('smessage', (subscribedChannel, message) => {
+          if (subscribedChannel === channel) {
+            callback(JSON.parse(message))
+          }
+        })
+      } else {
+        await this.subscriberClient.subscribe(channel)
+        this.subscriberClient.on('message', (subscribedChannel, message) => {
+          if (subscribedChannel === channel) {
+            callback(JSON.parse(message))
+          }
+        })
+      }
       this.log.info(`Subscribed to channel: ${channel}`)
       return channel
     } catch (err) {
@@ -139,7 +152,11 @@ class PubSub {
 
   async unsubscribe (channel) {
     try {
-      await this.subscriberClient.unsubscribe(channel)
+      if (this.isCluster) {
+        await this.subscriberClient.sunsubscribe(channel)
+      } else {
+        await this.subscriberClient.unsubscribe(channel)
+      }
       this.log.info(`Unsubscribed from channel: ${channel}`)
     } catch (err) {
       this.log.error('Error unsubscribing from channel:', err)

package/test/unit/util/redis/pubSub.test.js

@@ -371,5 +371,153 @@ Test('PubSub', (t) => {
     t.deepEqual(connectionStatus, { publisherConnected: false, subscriberConnected: false }, 'isConnected returns false statuses when clients are not connected')
     t.end()
   })
+  t.test('should publish a message to a channel using spublish when isCluster is true', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const message = { key: 'cluster-value' }
+
+    sandbox.stub(pubSub.publisherClient, 'spublish').resolves()
+
+    await pubSub.publish(channel, message)
+
+    t.ok(pubSub.publisherClient.spublish.calledWith(channel, JSON.stringify(message)), 'spublish called with correct arguments')
+    t.end()
+  })
+
+  t.test('should handle error when publishing a message with spublish in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const message = { key: 'cluster-value' }
+    const error = new Error('Cluster spublish error')
+
+    sandbox.stub(pubSub.publisherClient, 'spublish').rejects(error)
+
+    try {
+      await pubSub.publish(channel, message)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+    }
+    t.end()
+  })
+
+  t.test('should subscribe to a channel and handle smessage in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const callback = sinon.stub()
+    const message = JSON.stringify({ key: 'cluster-value' })
+
+    sandbox.stub(pubSub.subscriberClient, 'ssubscribe').resolves()
+    pubSub.subscriberClient.on.withArgs('smessage').yields(channel, message)
+
+    await pubSub.subscribe(channel, callback)
+
+    t.ok(pubSub.subscriberClient.ssubscribe.calledWith(channel), 'ssubscribe called with correct channel')
+    t.ok(callback.calledWith(JSON.parse(message)), 'callback called with parsed message')
+    t.end()
+  })
+
+  t.test('should not call callback if smessage subscribedChannel does not match channel in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const callback = sinon.stub()
+    const message = JSON.stringify({ key: 'cluster-value' })
+    const otherChannel = 'other-cluster-channel'
+
+    sandbox.stub(pubSub.subscriberClient, 'ssubscribe').resolves()
+    pubSub.subscriberClient.on.withArgs('smessage').yields(otherChannel, message)
+
+    await pubSub.subscribe(channel, callback)
+
+    t.ok(pubSub.subscriberClient.ssubscribe.calledWith(channel), 'ssubscribe called with correct channel')
+    t.notOk(callback.called, 'callback not called when smessage channel does not match')
+    t.end()
+  })
+
+  t.test('should handle error when subscribing to a channel in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const callback = sinon.stub()
+    const error = new Error('Cluster subscribe error')
+
+    sandbox.stub(pubSub.subscriberClient, 'ssubscribe').rejects(error)
+
+    try {
+      await pubSub.subscribe(channel, callback)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+    }
+    t.end()
+  })
+
+  t.test('should unsubscribe from a channel using sunsubscribe in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+
+    sandbox.stub(pubSub.subscriberClient, 'sunsubscribe').resolves()
+
+    await pubSub.unsubscribe(channel)
+
+    t.ok(pubSub.subscriberClient.sunsubscribe.calledWith(channel), 'sunsubscribe called with correct channel')
+    t.end()
+  })
+
+  t.test('should handle error when unsubscribing from a channel in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const error = new Error('Cluster unsubscribe error')
+
+    sandbox.stub(pubSub.subscriberClient, 'sunsubscribe').rejects(error)
+
+    try {
+      await pubSub.unsubscribe(channel)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+    }
+    t.end()
+  })
+
+  t.test('should broadcast a message to multiple channels using spublish in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channels = ['cluster1', 'cluster2']
+    const message = { key: 'cluster-broadcast' }
+
+    sandbox.stub(pubSub.publisherClient, 'spublish').resolves()
+
+    await pubSub.broadcast(channels, message)
+
+    t.ok(pubSub.publisherClient.spublish.calledTwice, 'spublish called twice')
+    t.ok(pubSub.publisherClient.spublish.firstCall.calledWith(channels[0], JSON.stringify(message)), 'spublish called with first channel and message')
+    t.ok(pubSub.publisherClient.spublish.secondCall.calledWith(channels[1], JSON.stringify(message)), 'spublish called with second channel and message')
+    t.end()
+  })
+
+  t.test('should handle error when broadcasting a message in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channels = ['cluster1', 'cluster2']
+    const message = { key: 'cluster-broadcast' }
+    const error = new Error('Cluster broadcast error')
+
+    sandbox.stub(pubSub.publisherClient, 'spublish').onFirstCall().rejects(error)
+
+    try {
+      await pubSub.broadcast(channels, message)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+    }
+    t.end()
+  })
   t.end()
 })