@mojaloop/sdk-scheme-adapter 24.10.7 → 24.10.9-snapshot.0

package/modules/api-svc/src/lib/model/common/TimeoutError.js

@@ -0,0 +1,41 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ - Name Surname <name.surname@mojaloop.io>
+
+ * Infitx
+ - Vijay Kumar Guthi - <vijaya.guthi@infitx.com>
+ --------------
+ ******/
+'use strict';
+
+class TimeoutError extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = 'TimeoutError';
+    }
+}
+
+
+module.exports = {
+    TimeoutError
+};

package/modules/api-svc/src/lib/model/common/index.js

@@ -28,10 +28,12 @@
  ******/
 const Enums = require('./Enums');
 const { BackendError } = require('./BackendError');
+const { TimeoutError } = require('./TimeoutError');
 const PersistentStateMachine = require('./PersistentStateMachine');
 
 module.exports = {
     ...Enums,
     BackendError,
+    TimeoutError,
     PersistentStateMachine
 };

package/modules/api-svc/src/lib/model/lib/requests/backendRequests.js

@@ -124,9 +124,9 @@ class BackendRequests {
         return this._post('fxTransfers', payload);
     }
 
-    async patchFxTransfersNotification(notification, conversionId) {
+    async putFxTransfersNotification(notification, conversionId) {
         const url = `fxTransfers/${conversionId}`;
-        return this._patch(url, notification);
+        return this._put(url, notification);
     }
 
     /**

package/modules/api-svc/test/unit/api/transfers/transfers.test.js

@@ -147,7 +147,7 @@ describe('Outbound Transfers API', () => {
                 parties: {
                     put: () => new Promise(
                         resolve => setTimeout(() => resolve(putPartiesBody),
-                            2000)),
+                            3000)),
                 },
             };
             return testPostTransfers(putBodyFn, 504, postTransfersErrorTimeoutResponse);

package/modules/api-svc/test/unit/inboundApi/handlers.test.js

@@ -1075,8 +1075,8 @@ describe('Inbound API handlers:', () => {
             };
         });
 
-        test('calls `model.sendFxPatchNotificationToBackend with expected arguments', async () => {
-            const notificationSpy = jest.spyOn(Model.prototype, 'sendFxPatchNotificationToBackend');
+        test('calls `model.sendFxPutNotificationToBackend with expected arguments', async () => {
+            const notificationSpy = jest.spyOn(Model.prototype, 'sendFxPutNotificationToBackend');
 
             await expect(handlers['/fxTransfers/{ID}'].patch(mockNotificationMessage)).resolves.toBe(undefined);
             expect(notificationSpy).toHaveBeenCalledTimes(1);

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/api-svc/test/unit/lib/model/InboundTransfersModel.test.js

@@ -842,7 +842,7 @@ describe('inboundModel', () => {
 
     });
 
-    describe('sendFxPatchNotificationToBackend:', () => {
+    describe('sendFxPutNotificationToBackend:', () => {
         const conversionId = '1234';
         let cache;
 
@@ -860,14 +860,9 @@ describe('inboundModel', () => {
         });
 
         test('sends notification to fsp backend', async () => {
-            BackendRequests.__patchFxTransfersNotification = jest.fn().mockReturnValue(Promise.resolve({}));
+            BackendRequests.__putFxTransfersNotification = jest.fn().mockReturnValue(Promise.resolve({}));
             const notif = JSON.parse(JSON.stringify(fxNotificationToBackend));
 
-            const expectedRequest = {
-                currentState: SDKStateEnum.COMPLETED,
-                finalNotification: notif.data,
-            };
-
             const model = new Model({
                 ...config,
                 cache,
@@ -875,22 +870,17 @@ describe('inboundModel', () => {
             });
             model.saveFxState = jest.fn().mockReturnValue(Promise.resolve({}));
 
-            await model.sendFxPatchNotificationToBackend(notif.data, conversionId);
-            expect(BackendRequests.__patchFxTransfersNotification).toHaveBeenCalledTimes(1);
-            const call = BackendRequests.__patchFxTransfersNotification.mock.calls[0];
-            expect(call[0]).toEqual(expectedRequest);
+            await model.sendFxPutNotificationToBackend(notif.data, conversionId);
+            expect(BackendRequests.__putFxTransfersNotification).toHaveBeenCalledTimes(1);
+            const call = BackendRequests.__putFxTransfersNotification.mock.calls[0];
+            expect(call[0]).toEqual(fxNotificationToBackend.data);
             expect(call[1]).toEqual(conversionId);
         });
 
         test('sends ABORTED notification to fsp backend', async () => {
-            BackendRequests.__patchFxTransfersNotification = jest.fn().mockReturnValue(Promise.resolve({}));
+            BackendRequests.__putFxTransfersNotification = jest.fn().mockReturnValue(Promise.resolve({}));
             const notif = JSON.parse(JSON.stringify(fxNotificationAbortedToBackend));
 
-            const expectedRequest = {
-                currentState: SDKStateEnum.ABORTED,
-                finalNotification: notif.data,
-            };
-
             const model = new Model({
                 ...config,
                 cache,
@@ -898,23 +888,17 @@ describe('inboundModel', () => {
             });
             model.saveFxState = jest.fn().mockReturnValue(Promise.resolve({}));
 
-            await model.sendFxPatchNotificationToBackend(notif.data, conversionId);
-            expect(BackendRequests.__patchFxTransfersNotification).toHaveBeenCalledTimes(1);
-            const call = BackendRequests.__patchFxTransfersNotification.mock.calls[0];
-            expect(call[0]).toEqual(expectedRequest);
+            await model.sendFxPutNotificationToBackend(notif.data, conversionId);
+            expect(BackendRequests.__putFxTransfersNotification).toHaveBeenCalledTimes(1);
+            const call = BackendRequests.__putFxTransfersNotification.mock.calls[0];
+            expect(call[0]).toEqual(fxNotificationAbortedToBackend.data);
             expect(call[1]).toEqual(conversionId);
         });
 
         test('sends RESERVED notification to fsp backend', async () => {
-            BackendRequests.__patchFxTransfersNotification = jest.fn().mockReturnValue(Promise.resolve({}));
+            BackendRequests.__putFxTransfersNotification = jest.fn().mockReturnValue(Promise.resolve({}));
             const notif = JSON.parse(JSON.stringify(fxNotificationReservedToBackend));
 
-            const expectedRequest = {
-                currentState: SDKStateEnum.ERROR_OCCURRED,
-                finalNotification: notif.data,
-                lastError: 'Final notification state not COMMITTED or ABORTED',
-            };
-
             const model = new Model({
                 ...config,
                 cache,
@@ -922,10 +906,10 @@ describe('inboundModel', () => {
             });
             model.saveFxState = jest.fn().mockReturnValue(Promise.resolve({}));
 
-            await model.sendFxPatchNotificationToBackend(notif.data, conversionId);
-            expect(BackendRequests.__patchFxTransfersNotification).toHaveBeenCalledTimes(1);
-            const call = BackendRequests.__patchFxTransfersNotification.mock.calls[0];
-            expect(call[0]).toEqual(expectedRequest);
+            await model.sendFxPutNotificationToBackend(notif.data, conversionId);
+            expect(BackendRequests.__putFxTransfersNotification).toHaveBeenCalledTimes(1);
+            const call = BackendRequests.__putFxTransfersNotification.mock.calls[0];
+            expect(call[0]).toEqual(fxNotificationReservedToBackend.data);
             expect(call[1]).toEqual(conversionId);
         });
 

package/modules/api-svc/test/unit/lib/model/mockedLibRequests.js

@@ -52,7 +52,7 @@ class MockBackendRequests extends BackendRequests {
         this.putTransfersNotification = MockBackendRequests.__putTransfersNotification;
         this.postFxQuotes = MockBackendRequests.__postFxQuotes;
         this.postFxTransfers = MockBackendRequests.__postFxTransfers;
-        this.patchFxTransfersNotification = MockBackendRequests.__patchFxTransfersNotification;
+        this.putFxTransfersNotification = MockBackendRequests.__putFxTransfersNotification;
     }
 }
 MockBackendRequests.__getParties = jest.fn(() => Promise.resolve({body: {}}));
@@ -68,7 +68,7 @@ MockBackendRequests.__postBulkTransfers = jest.fn(() => Promise.resolve({body: {
 MockBackendRequests.__putTransfersNotification = jest.fn(() => Promise.resolve({body: {}}));
 MockBackendRequests.__postFxQuotes = jest.fn(async () => ({ body: {} }));
 MockBackendRequests.__postFxTransfers = jest.fn(async () => ({ body: {} }));
-MockBackendRequests.__patchFxTransfersNotification = jest.fn(() => Promise.resolve({body: {}}));
+MockBackendRequests.__putFxTransfersNotification = jest.fn(() => Promise.resolve({body: {}}));
 
 class HTTPResponseError extends Error {
     constructor(params) {

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

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter-outbound-command-event-handler",
-  "version": "0.3.0-snapshot.46",
+  "version": "0.3.0-snapshot.48",
   "description": "Mojaloop sdk scheme adapter command event handler",
   "license": "Apache-2.0",
   "homepage": "https://github.com/mojaloop/sdk-scheme-adapter/",
@@ -50,8 +50,8 @@
     "ajv-formats": "3.0.1",
     "convict": "6.2.4",
     "express": "4.21.2",
-    "openapi-backend": "5.13.0",
-    "redis": "5.8.0",
+    "openapi-backend": "5.14.0",
+    "redis": "5.8.1",
     "swagger-ui-express": "5.0.1",
     "yamljs": "0.3.0"
   },
@@ -65,8 +65,8 @@
     "@types/supertest": "6.0.3",
     "@types/swagger-ui-express": "4.1.8",
     "@types/yamljs": "0.2.34",
-    "@typescript-eslint/eslint-plugin": "8.39.0",
-    "@typescript-eslint/parser": "8.39.0",
+    "@typescript-eslint/eslint-plugin": "8.39.1",
+    "@typescript-eslint/parser": "8.39.1",
     "copyfiles": "2.4.1",
     "eslint": "9.15.0",
     "jest": "29.7.0",

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

@@ -1,6 +1,6 @@
 {
     "name": "@mojaloop/sdk-scheme-adapter-outbound-domain-event-handler",
-    "version": "0.3.0-snapshot.46",
+    "version": "0.3.0-snapshot.48",
     "description": "mojaloop sdk scheme adapter outbound domain event handler",
     "license": "Apache-2.0",
     "homepage": "https://github.com/mojaloop/sdk-scheme-adapter/",
@@ -48,8 +48,8 @@
         "ajv-formats": "3.0.1",
         "convict": "6.2.4",
         "express": "4.21.2",
-        "openapi-backend": "5.13.0",
-        "redis": "5.8.0",
+        "openapi-backend": "5.14.0",
+        "redis": "5.8.1",
         "swagger-ui-express": "5.0.1",
         "yamljs": "0.3.0"
     },
@@ -62,8 +62,8 @@
         "@types/supertest": "6.0.3",
         "@types/swagger-ui-express": "4.1.8",
         "@types/yamljs": "0.2.34",
-        "@typescript-eslint/eslint-plugin": "8.39.0",
-        "@typescript-eslint/parser": "8.39.0",
+        "@typescript-eslint/eslint-plugin": "8.39.1",
+        "@typescript-eslint/parser": "8.39.1",
         "copyfiles": "2.4.1",
         "eslint": "9.15.0",
         "jest": "29.7.0",

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

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter-private-shared-lib",
-  "version": "0.4.0-snapshot.46",
+  "version": "0.4.0-snapshot.48",
   "description": "SDK Scheme Adapter private shared library.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/mojaloop/accounts-and-balances-bc/tree/main/modules/private-types",
@@ -35,15 +35,15 @@
     "@mojaloop/platform-shared-lib-messaging-types-lib": "0.7.3",
     "@mojaloop/platform-shared-lib-nodejs-kafka-client-lib": "0.5.18",
     "ajv": "8.17.1",
-    "redis": "5.8.0",
+    "redis": "5.8.1",
     "uuid": "11.1.0"
   },
   "devDependencies": {
     "@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",
+    "@typescript-eslint/eslint-plugin": "8.39.1",
+    "@typescript-eslint/parser": "8.39.1",
     "eslint": "9.15.0",
     "jest": "29.7.0",
     "npm-check-updates": "16.7.10",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter",
-  "version": "24.10.7",
+  "version": "24.10.9-snapshot.0",
   "description": "mojaloop sdk-scheme-adapter",
   "license": "Apache-2.0",
   "homepage": "https://github.com/mojaloop/sdk-scheme-adapter",
@@ -84,8 +84,8 @@
     "@types/jest": "30.0.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",
+    "@typescript-eslint/eslint-plugin": "8.39.1",
+    "@typescript-eslint/parser": "8.39.1",
     "audit-ci": "7.1.0",
     "eslint": "9.15.0",
     "eslint-config-airbnb-typescript": "18.0.0",