@mojaloop/sdk-scheme-adapter 24.10.6-snapshot.0 → 24.10.8

package/CHANGELOG.md

@@ -1,4 +1,40 @@
 # Changelog: [mojaloop/sdk-scheme-adapter](https://github.com/mojaloop/sdk-scheme-adapter)
+### [24.10.8](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.10.7...v24.10.8) (2025-08-11)
+
+
+### Bug Fixes
+
+* concurrency issues ([#601](https://github.com/mojaloop/sdk-scheme-adapter/issues/601)) ([b693e2f](https://github.com/mojaloop/sdk-scheme-adapter/commit/b693e2fe618f256e4511fe9fad256f48d814ca01))
+
+
+### Chore
+
+* **sbom:** update sbom [skip ci] ([63b0609](https://github.com/mojaloop/sdk-scheme-adapter/commit/63b06090017264a5d375d48bb9800ca9ae183ddd))
+
+### [24.10.7](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.10.6...v24.10.7) (2025-08-08)
+
+
+### Bug Fixes
+
+* revert dockerfile change ([#604](https://github.com/mojaloop/sdk-scheme-adapter/issues/604)) ([8ae897c](https://github.com/mojaloop/sdk-scheme-adapter/commit/8ae897cd4e566aed3469528f829ca201686dfeee))
+
+
+### Chore
+
+* **sbom:** update sbom [skip ci] ([e831089](https://github.com/mojaloop/sdk-scheme-adapter/commit/e831089e0a8df20a8c002b1fccda92de89631eac))
+
+### [24.10.6](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.10.5...v24.10.6) (2025-08-07)
+
+
+### Bug Fixes
+
+* issue EROFS from Yarn + Node 22 ([#603](https://github.com/mojaloop/sdk-scheme-adapter/issues/603)) ([503fe96](https://github.com/mojaloop/sdk-scheme-adapter/commit/503fe96d09e633b151132acd3695b518f0dd9057))
+
+
+### Chore
+
+* **sbom:** update sbom [skip ci] ([b361f4f](https://github.com/mojaloop/sdk-scheme-adapter/commit/b361f4f4f6a09b7e9e19d9e267e4e875ea76b668))
+
 ### [24.10.5](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.10.4...v24.10.5) (2025-08-01)
 
 

package/modules/api-svc/package.json

@@ -68,7 +68,7 @@
     "@mojaloop/central-services-error-handling": "13.1.0",
     "@mojaloop/central-services-logger": "11.9.0",
     "@mojaloop/central-services-metrics": "12.6.0",
-    "@mojaloop/central-services-shared": "18.30.6",
+    "@mojaloop/central-services-shared": "18.30.7",
     "@mojaloop/event-sdk": "14.6.1",
     "@mojaloop/logging-bc-client-lib": "0.5.8",
     "@mojaloop/ml-schema-transformer-lib": "2.7.7",
@@ -115,7 +115,7 @@
     "jest-junit": "16.0.0",
     "npm-check-updates": "16.7.10",
     "openapi-response-validator": "12.1.3",
-    "openapi-typescript": "7.8.0",
+    "openapi-typescript": "7.9.0",
     "redis-mock": "0.56.3",
     "replace": "1.2.2",
     "standard-version": "9.5.0",

package/modules/api-svc/src/lib/cache.js

@@ -200,52 +200,104 @@ class Cache {
     }
 
     /**
-     * Subscribes to a channel for some period and always returns resolved promise
+     * Subscribes to a channel and waits for a single message with timeout support.
+     * 
+     * NOTE:
+     * This implementation uses EventEmitter to handle Redis pub/sub concurrency issues
+     * that occur when multiple subscribers listen to the same channel simultaneously.
+     * It's designed to prevent race conditions in party lookups where concurrent requests
+     * for the same party ID could interfere with each other.
+     * Currently used for: Party lookup operations
+     * Future potential: This function can be extended to other scenarios and potentially
+     * replace the existing subscribe, unsubscribe, and subscribeToOneMessageWithTimer
+     * functions for a more robust and concurrency-safe pub/sub implementation.
      *
      * @param {string} channel - The channel name to subscribe to
-     * @param {boolean} [needParse=true] - specify if the message should be parsed before returning
+     * @param {number} requestProcessingTimeoutSeconds - Timeout in seconds before rejecting with TimeoutError
+     * @param {boolean} [needParse=true] - Whether to JSON.parse the received message
      *
-     * @returns {Promise} - Promise that resolves with a message or an error
+     * @returns {Promise<any>} Promise that resolves with the message or rejects with TimeoutError/Error
      */
     async subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds, needParse = true) {
-        let subscription;
-
         return new Promise((resolve, reject) => {
+            let timeoutHandle = null;
+            let subscription = null;
+            let isResolved = false;
+
+            // Helper to safely unsubscribe from Redis channel
+            const unsubscribeFromRedis = async (reason = 'cleanup') => {
+                if (this._channelEmitter.listenerCount(channel) === 0 && this._subscriptionClient) {
+                    try {
+                        await this._subscriptionClient.unsubscribe(channel);
+                        this._logger.push({ channel, reason }).debug('Unsubscribed from Redis channel');
+                    } catch (unsubscribeErr) {
+                        this._logger.push({ channel, reason }).warn('Failed to unsubscribe from Redis channel', unsubscribeErr);
+                    }
+                }
+            };
 
-            const timer = setTimeout(async () => {
+            // Helper to clean up resources and prevent multiple resolutions
+            const cleanup = () => {
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                    timeoutHandle = null;
+                }
                 if (subscription) {
                     this._channelEmitter.removeListener(channel, subscription);
+                    subscription = null;
                 }
-                // If there are no listeners left for this channel, we can unsubscribe
-                if (this._channelEmitter.listenerCount(channel) === 0) {
-                    if (this._subscriptionClient) {
-                        await this._subscriptionClient.unsubscribe(channel);
-                    }
-                }
-                const errMessage = 'Timeout error';
-                this._logger.push({ channel }).warn(errMessage);
+            };
+
+            // Set up timeout handler
+            timeoutHandle = setTimeout(async () => {
+                if (isResolved) return;
+                isResolved = true;
+
+                cleanup();
+                await unsubscribeFromRedis('timeout');
+
+                const errMessage = `Subscription timeout after ${requestProcessingTimeoutSeconds}s`;
+                this._logger.push({ channel, timeout: requestProcessingTimeoutSeconds }).warn(errMessage);
                 reject(new TimeoutError(errMessage));
             }, requestProcessingTimeoutSeconds * 1000);
 
+            // Set up message handler
             subscription = (message) => {
-                this._logger.push({ channel, message, needParse }).debug('subscribeToOneMessageWithTimer is done');
-                clearTimeout(timer);
-                resolve(needParse ? JSON.parse(message) : message);
+                if (isResolved) return;
+                isResolved = true;
+
+                this._logger.push({ channel, needParse }).debug('Received message on subscribed channel');
+                
+                cleanup();
+
+                try {
+                    const result = needParse ? JSON.parse(message) : message;
+                    resolve(result);
+                } catch (parseErr) {
+                    this._logger.push({ channel, message }).error('Failed to parse received message', parseErr);
+                    reject(parseErr);
+                }
             };
+
+            // Register the one-time listener
             this._channelEmitter.once(channel, subscription);
 
-            this._subscriptionClient.subscribe(channel, async (msg) => {
+            // Subscribe to Redis channel
+            this._subscriptionClient.subscribe(channel, (msg) => {
                 this._channelEmitter.emit(channel, msg);
-                // If there are no listeners left for this channel, we can unsubscribe
-                if (this._channelEmitter.listenerCount(channel) === 0) {
-                    if (this._subscriptionClient) {
-                        await this._subscriptionClient.unsubscribe(channel);
-                    }
-                }
+                
+                // Auto-unsubscribe if no more listeners
+                unsubscribeFromRedis('auto-cleanup').catch(err => {
+                    this._logger.push({ channel }).warn('Auto-unsubscribe failed', err);
+                });
             })
-                .catch(err => {
-                    this._logger.push({ channel, err }).warn(`error in subscribeToOneMessageWithTimer: ${err.message}`);
-                    reject(err);
+                .catch(subscribeErr => {
+                    if (isResolved) return;
+                    isResolved = true;
+
+                    cleanup();
+                    this._logger.push({ channel }).error('Failed to subscribe to Redis channel', subscribeErr);
+                    reject(subscribeErr);
                 });
         });
     }

package/modules/api-svc/src/lib/model/OutboundTransfersModel.js

@@ -340,7 +340,7 @@ class OutboundTransfersModel {
                 this.data.getPartiesRequest = res.originalRequest;
 
                 this.metrics.partyLookupRequests.inc();
-                this._logger.isDebugEnabled && this._logger.push({ peer: res }).debug('Party lookup sent to peer');
+                this._logger.push({ peer: res }).debug('Party lookup sent to peer');
 
                 const message = await subscribing;
 
@@ -365,7 +365,7 @@ class OutboundTransfersModel {
 
                 payee = payee.party;
 
-                this._logger.isVerboseEnabled && this._logger.push({ payee }).verbose('Payee resolved');
+                this._logger.push({ payee }).verbose('Payee resolved');
 
                 // check we got the right payee and info we need
                 if(payee.partyIdInfo.partyIdType !== this.data.to.idType) {
@@ -412,7 +412,7 @@ class OutboundTransfersModel {
                     this.data.supportedCurrencies = payee.supportedCurrencies;
                 }
 
-                this._logger.isVerboseEnabled && this._logger.push({
+                this._logger.push({
                     transferId: this.data.transferId,
                     homeTransactionId: this.data.homeTransactionId,
                     needFx: this.data.needFx,
@@ -421,7 +421,7 @@ class OutboundTransfersModel {
                 return resolve(payee);
             }
             catch(err) {
-                this._logger.isErrorEnabled && this._logger.error(`Error in resolvePayee ${payeeKey}: ${err.stack || safeStringify(err)}`);
+                this._logger.error(`Error in resolvePayee ${payeeKey}:`, err);
                 // If type of error is BackendError, it will be handled by the state machine
                 if (err instanceof BackendError) {
                     this.data.lastError = err;

package/modules/api-svc/test/unit/lib/cache.test.js

@@ -210,4 +210,154 @@ describe('Cache Tests -->', () => {
         expect(result).toEqual(error);
         expect(unsubscribeSpy).not.toHaveBeenCalled();
     });
+
+    test('subscribeToOneMessageWithTimerNew should resolve with parsed message when received before timeout', async () => {
+        const channel = `ch-${randomUUID()}`;
+        const message = { id: randomUUID(), data: 'test-data' };
+        const requestProcessingTimeoutSeconds = 1;
+
+        const subscribing = cache.subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds);
+        
+        // Simulate a message being published to the channel via EventEmitter
+        setTimeout(() => {
+            cache._channelEmitter.emit(channel, JSON.stringify(message));
+        }, 100);
+
+        const result = await subscribing;
+        expect(result).toStrictEqual(message);
+    });
+
+    test('subscribeToOneMessageWithTimerNew should resolve with unparsed message when needParse is false', async () => {
+        const channel = `ch-${randomUUID()}`;
+        const message = 'raw-string-message';
+        const requestProcessingTimeoutSeconds = 1;
+
+        const subscribing = cache.subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds, false);
+        
+        // Simulate a message being published to the channel via EventEmitter
+        setTimeout(() => {
+            cache._channelEmitter.emit(channel, message);
+        }, 100);
+
+        const result = await subscribing;
+        expect(result).toBe(message);
+    });
+
+    test('subscribeToOneMessageWithTimerNew should reject with TimeoutError when no message received within timeout', async () => {
+        const channel = `ch-${randomUUID()}`;
+        const requestProcessingTimeoutSeconds = 0.1; // 100ms timeout
+
+        const subscribing = cache.subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds);
+
+        await expect(subscribing).rejects.toThrow(`Subscription timeout after ${requestProcessingTimeoutSeconds}s`);
+        
+        // Test that it's a TimeoutError instance
+        try {
+            await subscribing;
+            expect(true).toBe(false); // Should not reach here
+        } catch (error) {
+            expect(error.constructor.name).toBe('TimeoutError');
+        }
+    });
+
+    test('subscribeToOneMessageWithTimerNew should reject when JSON parsing fails', async () => {
+        const channel = `ch-${randomUUID()}`;
+        const invalidJson = '{ invalid json }';
+        const requestProcessingTimeoutSeconds = 1;
+
+        const subscribing = cache.subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds, true);
+        
+        // Simulate a message with invalid JSON
+        setTimeout(() => {
+            cache._channelEmitter.emit(channel, invalidJson);
+        }, 100);
+
+        await expect(subscribing).rejects.toThrow();
+    });
+
+    test('subscribeToOneMessageWithTimerNew should handle multiple subscribers to same channel', async () => {
+        const channel1 = `ch-${randomUUID()}`;
+        const channel2 = `ch-${randomUUID()}`;
+        const message1 = { id: 'msg1', data: 'test1' };
+        const message2 = { id: 'msg2', data: 'test2' };
+        const requestProcessingTimeoutSeconds = 1;
+
+        // Create two subscriptions to different channels to avoid interference
+        const subscribing1 = cache.subscribeToOneMessageWithTimerNew(channel1, requestProcessingTimeoutSeconds);
+        const subscribing2 = cache.subscribeToOneMessageWithTimerNew(channel2, requestProcessingTimeoutSeconds);
+        
+        // Emit messages to each channel separately
+        setTimeout(() => {
+            cache._channelEmitter.emit(channel1, JSON.stringify(message1));
+            cache._channelEmitter.emit(channel2, JSON.stringify(message2));
+        }, 100);
+
+        // Both should resolve with their respective messages
+        const results = await Promise.all([subscribing1, subscribing2]);
+        expect(results[0]).toStrictEqual(message1);
+        expect(results[1]).toStrictEqual(message2);
+    });
+
+    test('subscribeToOneMessageWithTimerNew should handle concurrent subscribers to same channel (party lookup scenario)', async () => {
+        const channel = `party-lookup-${randomUUID()}`;
+        const partyResponse = { party: { partyIdInfo: { partyIdType: 'MSISDN', partyIdentifier: '123456789' }}};
+        const requestProcessingTimeoutSeconds = 1;
+
+        // Create multiple concurrent subscriptions to same channel (simulating concurrent party lookups)
+        const subscribing1 = cache.subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds);
+        const subscribing2 = cache.subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds);
+        const subscribing3 = cache.subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds);
+        
+        // Simulate a single party response that should resolve all subscribers
+        setTimeout(() => {
+            cache._channelEmitter.emit(channel, JSON.stringify(partyResponse));
+        }, 100);
+
+        // All subscribers should resolve with the same party response
+        const results = await Promise.all([subscribing1, subscribing2, subscribing3]);
+        expect(results[0]).toStrictEqual(partyResponse);
+        expect(results[1]).toStrictEqual(partyResponse);
+        expect(results[2]).toStrictEqual(partyResponse);
+    });
+
+    test('subscribeToOneMessageWithTimerNew should clean up resources on timeout', async () => {
+        const channel = `ch-${randomUUID()}`;
+        const requestProcessingTimeoutSeconds = 0.1;
+        
+        const removeListenerSpy = jest.spyOn(cache._channelEmitter, 'removeListener');
+        
+        const subscribing = cache.subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds);
+
+        await expect(subscribing).rejects.toThrow(`Subscription timeout after ${requestProcessingTimeoutSeconds}s`);
+        
+        // Test that it's a TimeoutError instance
+        try {
+            await subscribing;
+            expect(true).toBe(false); // Should not reach here
+        } catch (error) {
+            expect(error.constructor.name).toBe('TimeoutError');
+        }
+        
+        // Verify cleanup was called
+        expect(removeListenerSpy).toHaveBeenCalledWith(channel, expect.any(Function));
+        
+        removeListenerSpy.mockRestore();
+    });
+
+    test('subscribeToOneMessageWithTimerNew should reject when subscription fails', async () => {
+        const channel = `ch-${randomUUID()}`;
+        const requestProcessingTimeoutSeconds = 1;
+        const subscriptionError = new Error('subscription failed');
+
+        // Mock the _subscriptionClient.subscribe to reject
+        const originalSubscribe = cache._subscriptionClient.subscribe;
+        cache._subscriptionClient.subscribe = jest.fn().mockRejectedValue(subscriptionError);
+
+        const subscribing = cache.subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds);
+
+        await expect(subscribing).rejects.toThrow('subscription failed');
+        
+        // Restore original method
+        cache._subscriptionClient.subscribe = originalSubscribe;
+    });
 });

package/modules/outbound-command-event-handler/package.json

@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@mojaloop/api-snippets": "18.1.1",
-    "@mojaloop/central-services-shared": "18.30.6",
+    "@mojaloop/central-services-shared": "18.30.7",
     "@mojaloop/logging-bc-client-lib": "0.5.8",
     "@mojaloop/logging-bc-public-types-lib": "0.5.6",
     "@mojaloop/sdk-scheme-adapter-private-shared-lib": "workspace:^",
@@ -56,11 +56,11 @@
     "yamljs": "0.3.0"
   },
   "devDependencies": {
-    "@eslint/compat": "1.3.1",
+    "@eslint/compat": "1.3.2",
     "@types/convict": "6.1.6",
     "@types/express": "5.0.3",
     "@types/jest": "30.0.0",
-    "@types/node": "24.2.0",
+    "@types/node": "24.2.1",
     "@types/node-cache": "4.2.5",
     "@types/supertest": "6.0.3",
     "@types/swagger-ui-express": "4.1.8",

package/modules/outbound-domain-event-handler/package.json

@@ -57,7 +57,7 @@
         "@types/convict": "6.1.6",
         "@types/express": "5.0.3",
         "@types/jest": "30.0.0",
-        "@types/node": "24.2.0",
+        "@types/node": "24.2.1",
         "@types/node-cache": "4.2.5",
         "@types/supertest": "6.0.3",
         "@types/swagger-ui-express": "4.1.8",

package/modules/private-shared-lib/package.json

@@ -30,7 +30,7 @@
   },
   "dependencies": {
     "@mojaloop/api-snippets": "18.1.1",
-    "@mojaloop/central-services-shared": "18.30.6",
+    "@mojaloop/central-services-shared": "18.30.7",
     "@mojaloop/logging-bc-public-types-lib": "0.5.6",
     "@mojaloop/platform-shared-lib-messaging-types-lib": "0.7.3",
     "@mojaloop/platform-shared-lib-nodejs-kafka-client-lib": "0.5.18",
@@ -39,8 +39,8 @@
     "uuid": "11.1.0"
   },
   "devDependencies": {
-    "@eslint/compat": "1.3.1",
-    "@types/node": "24.2.0",
+    "@eslint/compat": "1.3.2",
+    "@types/node": "24.2.1",
     "@types/uuid": "10.0.0",
     "@typescript-eslint/eslint-plugin": "8.39.0",
     "@typescript-eslint/parser": "8.39.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter",
-  "version": "24.10.6-snapshot.0",
+  "version": "24.10.8",
   "description": "mojaloop sdk-scheme-adapter",
   "license": "Apache-2.0",
   "homepage": "https://github.com/mojaloop/sdk-scheme-adapter",
@@ -82,7 +82,7 @@
   },
   "devDependencies": {
     "@types/jest": "30.0.0",
-    "@types/node": "24.2.0",
+    "@types/node": "24.2.1",
     "@types/node-cache": "4.2.5",
     "@typescript-eslint/eslint-plugin": "8.39.0",
     "@typescript-eslint/parser": "8.39.0",