@mojaloop/sdk-scheme-adapter 24.11.0-csi-1680.0 → 24.11.0-snapshot.1

package/.yarnrc.yml

@@ -4,4 +4,4 @@ enableGlobalCache: false
 
 nodeLinker: node-modules
 
-yarnPath: .yarn/releases/yarn-4.9.2.cjs
+yarnPath: .yarn/releases/yarn-4.9.4.cjs

package/CHANGELOG.md

@@ -1,4 +1,41 @@
 # Changelog: [mojaloop/sdk-scheme-adapter](https://github.com/mojaloop/sdk-scheme-adapter)
+### [24.10.11](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.10.10...v24.10.11) (2025-09-15)
+
+
+### Bug Fixes
+
+* ilp decimal calculation ([#612](https://github.com/mojaloop/sdk-scheme-adapter/issues/612)) ([77cdd19](https://github.com/mojaloop/sdk-scheme-adapter/commit/77cdd19dc2543f9bd115da4da55e1d3266d21e67))
+
+
+### Chore
+
+* grype exception ([#613](https://github.com/mojaloop/sdk-scheme-adapter/issues/613)) ([464f4fd](https://github.com/mojaloop/sdk-scheme-adapter/commit/464f4fd95feec2953106839c134296d2f51f05b3))
+* **sbom:** update sbom [skip ci] ([051986c](https://github.com/mojaloop/sdk-scheme-adapter/commit/051986ccc8bb51b616200239cb1727598fd29f74))
+
+### [24.10.10](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.10.9...v24.10.10) (2025-08-27)
+
+
+### Bug Fixes
+
+* **csi-1708:** updated deps ([#607](https://github.com/mojaloop/sdk-scheme-adapter/issues/607)) ([42f7baf](https://github.com/mojaloop/sdk-scheme-adapter/commit/42f7baf2e828e4eea2eb4edc41cd847d4e15651c))
+
+
+### Chore
+
+* **sbom:** update sbom [skip ci] ([c05eac1](https://github.com/mojaloop/sdk-scheme-adapter/commit/c05eac19196b19b1b3ff3c6cafc0744207e4b43d))
+
+### [24.10.9](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.10.8...v24.10.9) (2025-08-18)
+
+
+### Bug Fixes
+
+* **csi-1680:** changed PATCH transfers/fxTransfers logic of sending notifications ([#605](https://github.com/mojaloop/sdk-scheme-adapter/issues/605)) ([749d84a](https://github.com/mojaloop/sdk-scheme-adapter/commit/749d84a785a571b7f401b2e98f2852bc2ae175d8))
+
+
+### Chore
+
+* **sbom:** update sbom [skip ci] ([071b19e](https://github.com/mojaloop/sdk-scheme-adapter/commit/071b19e185aff5e3f5e17681c4032d85b8bc35e8))
+
 ### [24.10.8](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.10.7...v24.10.8) (2025-08-11)
 
 

package/modules/api-svc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter-api-svc",
-  "version": "21.0.0-snapshot.54",
+  "version": "21.0.0-snapshot.59",
   "description": "An adapter for connecting to Mojaloop API enabled switches.",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -65,20 +65,20 @@
   "dependencies": {
     "@koa/cors": "5.0.0",
     "@mojaloop/api-snippets": "18.1.1",
-    "@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.7",
-    "@mojaloop/event-sdk": "14.6.1",
+    "@mojaloop/central-services-error-handling": "13.1.2",
+    "@mojaloop/central-services-logger": "11.9.3",
+    "@mojaloop/central-services-metrics": "12.7.1",
+    "@mojaloop/central-services-shared": "18.33.0",
+    "@mojaloop/event-sdk": "14.7.0",
     "@mojaloop/logging-bc-client-lib": "0.5.8",
-    "@mojaloop/ml-schema-transformer-lib": "2.7.7",
+    "@mojaloop/ml-schema-transformer-lib": "2.7.8",
     "@mojaloop/sdk-scheme-adapter-private-shared-lib": "workspace:^",
-    "@mojaloop/sdk-standard-components": "19.16.4",
+    "@mojaloop/sdk-standard-components": "19.17.0",
     "ajv": "8.17.1",
-    "axios": "1.11.0",
+    "axios": "1.12.2",
     "body-parser": "2.2.0",
     "co-body": "6.2.0",
-    "dotenv": "17.2.1",
+    "dotenv": "17.2.2",
     "env-var": "7.5.0",
     "express": "4.21.2",
     "fast-json-patch": "3.1.1",
@@ -96,17 +96,19 @@
     "prom-client": "15.1.3",
     "promise-timeout": "1.3.0",
     "random-word-slugs": "0.1.7",
-    "redis": "5.8.1",
+    "redis": "5.8.2",
+    "retry": "^0.13.1",
     "uuidv4": "6.2.13",
     "ws": "8.18.3"
   },
   "devDependencies": {
-    "@babel/core": "7.28.3",
+    "@babel/core": "7.28.4",
     "@babel/preset-env": "7.28.3",
     "@redocly/openapi-cli": "1.0.0-beta.95",
     "@types/jest": "30.0.0",
+    "@types/retry": "^0",
     "axios-mock-adapter": "2.1.0",
-    "babel-jest": "30.0.5",
+    "babel-jest": "30.1.2",
     "eslint": "9.15.0",
     "eslint-config-airbnb-base": "15.0.0",
     "eslint-plugin-import": "2.32.0",

package/modules/api-svc/src/InboundServer/handlers.js

@@ -729,12 +729,22 @@ const patchTransfersById = async (ctx) => {
     // use the transfers model to execute asynchronous stages with the switch
     const model = createInboundTransfersModel(ctx);
 
-    // sends notification to the payee fsp
-    const response = await model.sendNotificationToPayee(req.data, idValue);
+    // kick off an asynchronous operation to handle the request
+    (async () => {
+        try {
+            // sends notification to the payee fsp
+            const response = await model.sendNotificationToPayee(req.data, idValue);
+
+            // log the result
+            ctx.state.logger.isDebugEnabled && ctx.state.logger.push({ response }).
+                debug('Inbound transfers model handled PATCH /transfers/{ID} request');
+        } catch (err) {
+            ctx.state.logger.isErrorEnabled && ctx.state.logger.push({ err }).error('Error handling PATCH /transfers/{ID}');
+        }
+    })();
 
-    // log the result
-    ctx.state.logger.isDebugEnabled && ctx.state.logger.push({response}).
-        debug('Inbound transfers model handled PATCH /transfers/{ID} request');
+    ctx.response.status = ReturnCodes.OK.CODE;
+    ctx.response.body = '';
 };
 
 /**
@@ -1080,10 +1090,18 @@ const patchFxTransfersById = async (ctx) => {
     const data = { ...ctx.request.body };
     const idValue = ctx.state.path.params.ID;
 
-    const model = createInboundTransfersModel(ctx);
-    const response = await model.sendFxPutNotificationToBackend(data, idValue);
+    (async () => {
+        const model = createInboundTransfersModel(ctx);
+        try {
+            const response = await model.sendFxPutNotificationToBackend(data, idValue);
+            ctx.state.logger.push({ response }).debug('Inbound Transfers model handled PATCH /fxTransfers/{ID} request');
+        } catch (err) {
+            ctx.state.logger.push({ err }).error('Error handling PATCH /fxTransfers/{ID}');
+        }
+    })();
 
-    ctx.state.logger.push({ response }).debug('Inbound Transfers model handled PATCH /fxTransfers/{ID} request');
+    ctx.response.status = ReturnCodes.OK.CODE;
+    ctx.response.body = '';
 };
 
 /**

package/modules/api-svc/src/config.js

@@ -264,5 +264,21 @@ module.exports = {
 
     // Redis key ttl when stored in the cache, if value is used as zero it will
     // persist throughout the session , value used is in seconds
-    redisCacheTtl: env.get('REDIS_CACHE_TTL').default('0').asInt()
+    redisCacheTtl: env.get('REDIS_CACHE_TTL').default('0').asInt(),
+
+    backendRequestRetry: {
+        enabled: env.get('BACKEND_REQUEST_RETRY_ENABLED').default('true').asBool(),
+        maxRetries: env.get('BACKEND_REQUEST_RETRY_MAX_RETRIES').default('5').asIntPositive(),
+        retryDelayMs: env.get('BACKEND_REQUEST_RETRY_DELAY_MS').default('1000').asIntPositive(),
+        maxRetryDelayMs: env.get('BACKEND_REQUEST_RETRY_MAX_DELAY_MS').default('10000').asIntPositive(),
+        backoffFactor: env.get('BACKEND_REQUEST_RETRY_BACKOFF_FACTOR').default('2').asIntPositive(),
+    },
+    getTransferRequestRetry: {
+        enabled: env.get('GET_TRANSFER_REQUEST_RETRY_ENABLED').default('false').asBool(),
+        maxRetries: env.get('GET_TRANSFER_REQUEST_RETRY_MAX_RETRIES').default('3').asIntPositive(),
+        retryDelayMs: env.get('GET_TRANSFER_REQUEST_RETRY_DELAY_MS').default('1000').asIntPositive(),
+        maxRetryDelayMs: env.get('GET_TRANSFER_REQUEST_RETRY_MAX_DELAY_MS').default('10000').asIntPositive(),
+        backoffFactor: env.get('GET_TRANSFER_REQUEST_RETRY_BACKOFF_FACTOR').default('2').asIntPositive(),
+    },
+    patchNotificationGraceTimeMs: env.get('PATCH_NOTIFICATION_GRACE_TIME_MS').default('15000').asIntPositive(),
 };

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

@@ -30,6 +30,7 @@ const safeStringify = require('fast-safe-stringify');
 const { MojaloopRequests, Ilp, Errors } = require('@mojaloop/sdk-standard-components');
 const FSPIOPTransferStateEnum = require('@mojaloop/central-services-shared').Enum.Transfers.TransferState;
 const FSPIOPBulkTransferStateEnum = require('@mojaloop/central-services-shared').Enum.Transfers.BulkTransferState;
+const retry = require('retry');
 
 const dto = require('../dto');
 const shared = require('./lib/shared');
@@ -52,6 +53,9 @@ class InboundTransfersModel {
         this._reserveNotification = config.reserveNotification;
         this._allowDifferentTransferTransactionId = config.allowDifferentTransferTransactionId;
         this._supportedCurrencies = config.supportedCurrencies;
+        this._patchNotificationGraceTimeMs = config.patchNotificationGraceTimeMs;
+        this._getTransferRequestRetry = config.getTransferRequestRetry;
+        this._backendRequestRetry = config.backendRequestRetry;
 
         this._mojaloopRequests = new MojaloopRequests({
             logger: this._logger,
@@ -489,6 +493,61 @@ class InboundTransfersModel {
             this.data.currentState = response.transferState || (this._reserveNotification ? SDKStateEnum.RESERVED : SDKStateEnum.COMPLETED);
 
             await this._save();
+
+            // --- PATCH NOTIFICATION TIMER LOGIC ---
+            // Set a timer to trigger GET /transfers/{ID} if sendNotificationToPayee is not called in time
+            if (this._patchNotificationGraceTimeMs > 0) {
+                const transferId = prepareRequest.transferId;
+                const cacheKey = `patchNotificationSent_${transferId}`;
+                // Mark as not notified yet
+                await this._cache.set(cacheKey, false, Math.ceil(this._patchNotificationGraceTimeMs / 1000) + 5);
+
+                setTimeout(async () => {
+                    try {
+                        this._logger.isInfoEnabled && this._logger.push({ transferId }).info('Patch notification grace time expired, attempting GET /transfers/{ID}');
+                        const notified = await this._cache.get(cacheKey);
+
+                        if (!notified) {
+                            // Subscribe to transfer callback channel
+                            const transferKey = `tf_${transferId}`;
+                            const unsubscribeTimeout = this._getTransferRequestRetry?.retryDelayMs || 1000;
+                            let gotCallback = false;
+
+                            // Subscribe for one message with a timeout
+                            const messagePromise = this._cache.subscribeToOneMessageWithTimer(transferKey, Math.ceil(unsubscribeTimeout / 1000));
+                            // Kick off GET /transfers/{ID}
+                            await this._mojaloopRequests.getTransfers(transferId, sourceFspId, headers);
+
+                            // Retry logic
+                            let attempts = 0;
+                            const maxAttempts = (this._getTransferRequestRetry?.maxRetries || 3);
+                            const retryDelay = this._getTransferRequestRetry?.retryDelayMs || 1000;
+                            while (attempts < maxAttempts && !gotCallback) {
+                                try {
+                                    const message = await messagePromise;
+                                    if (message && message.data) {
+                                        gotCallback = true;
+                                        // Mark as notified to prevent duplicate notification
+                                        await this._cache.set(cacheKey, true, 60);
+                                        // Send notification to payee
+                                        await this.sendNotificationToPayee(message.data.body, transferId);
+                                        break;
+                                    }
+                                } catch (err) {
+                                    this._logger.isErrorEnabled && this._logger.push({ err, transferId }).error('Error while waiting for transfer callback in patch notification grace timer logic');
+                                }
+                                attempts++;
+                                if (!gotCallback && attempts < maxAttempts) {
+                                    await this._mojaloopRequests.getTransfers(transferId, sourceFspId, headers);
+                                    await new Promise(r => setTimeout(r, retryDelay));
+                                }
+                            }
+                        }
+                    } catch (err) {
+                        this._logger.isErrorEnabled && this._logger.push({ err, transferId }).error('Error in patch notification grace timer logic');
+                    }
+                }, this._patchNotificationGraceTimeMs);
+            }
             return res;
         } catch(err) {
             this._logger.isErrorEnabled && this._logger.push({ err }).error(`Error in prepareTransfer: ${prepareRequest?.transferId}`);
@@ -956,7 +1015,7 @@ class InboundTransfersModel {
     async sendFxPutNotificationToBackend(body, conversionId) {
         const log = this._logger.child({ conversionId });
         try {
-            log.verbose('sendFxPutNotificationToBackend - incoming payload: ', { body });
+            log.verbose('sendFxPutNotificationToBackend incoming payload: ', { body });
             this.data = await this.loadFxState(conversionId);
 
             if(!this.data) {
@@ -978,12 +1037,51 @@ class InboundTransfersModel {
 
             const responseBody = {
                 conversionState: body.conversionState, // one of ABORTED, COMMITTED, RESERVED
-                completedTimestamp: body.completedTimestamp
+                completedTimestamp: body.completedTimestamp,
             };
-            log.verbose('sendFxPutNotificationToBackend - body sent to cc: ', { responseBody });
-
+            log.verbose('sendFxPutNotificationToBackend body sent to cc: ', { responseBody });
+
+            const { enabled, maxRetries, retryDelayMs, maxRetryDelayMs, backoffFactor } = this._backendRequestRetry || {};
+            let res;
+            const shouldRetry = enabled !== false; // default to true if not set
+
+            if (shouldRetry) {
+                const operation = retry.operation({
+                    retries: maxRetries || 5,
+                    factor: backoffFactor || 2,
+                    minTimeout: retryDelayMs || 1000,
+                    maxTimeout: maxRetryDelayMs || 10000,
+                });
+
+                await new Promise((resolve) => {
+                    operation.attempt(async (currentAttempt) => {
+                        try {
+                            res = await this._backendRequests.putFxTransfersNotification(responseBody, conversionId);
+                            if ((res && (res.status === 200 || res.statusCode === 200)) || res === true) {
+                                return resolve();
+                            }
+                            log.warn(`putFxTransfersNotification attempt ${currentAttempt} failed, retrying...`);
+                            if (!operation.retry(new Error('Non-200 response'))) {
+                                resolve();
+                            }
+                        } catch (err) {
+                            log.warn(`putFxTransfersNotification attempt ${currentAttempt} threw error, retrying...`, err);
+                            if (!operation.retry(err)) {
+                                resolve();
+                            }
+                        }
+                    });
+                });
 
-            const res = await this._backendRequests.putFxTransfersNotification(responseBody, conversionId);
+                if ((res && (res.status !== 200 && res.statusCode !== 200)) && res !== true) {
+                    log.error(`putFxTransfersNotification failed after ${operation.attempts()} attempts`);
+                }
+            } else {
+                res = await this._backendRequests.putFxTransfersNotification(responseBody, conversionId);
+                if ((res && (res.status !== 200 && res.statusCode !== 200)) && res !== true) {
+                    log.error('putFxTransfersNotification failed');
+                }
+            }
             return res;
         } catch (err) {
             log.error('error in sendFxPutNotificationToBackend: ', err);
@@ -1026,7 +1124,49 @@ class InboundTransfersModel {
 
             await this._save();
 
-            const res = await this._backendRequests.putTransfersNotification(this.data, transferId);
+            const { enabled, maxRetries, retryDelayMs, maxRetryDelayMs, backoffFactor } = this._backendRequestRetry || {};
+            let res;
+            const shouldRetry = enabled !== false; // default to true if not set
+
+            if (shouldRetry) {
+                const operation = retry.operation({
+                    retries: maxRetries || 5,
+                    factor: backoffFactor || 2,
+                    minTimeout: retryDelayMs || 1000,
+                    maxTimeout: maxRetryDelayMs || 10000,
+                });
+
+                await new Promise((resolve) => {
+                    operation.attempt(async (currentAttempt) => {
+                        try {
+                            res = await this._backendRequests.putTransfersNotification(this.data, transferId);
+                            if ((res && (res.status === 200 || res.statusCode === 200)) || res === true) {
+                                const cacheKey = `patchNotificationSent_${transferId}`;
+                                await this._cache.set(cacheKey, true, 60);
+                                return resolve();
+                            }
+                            this._logger.warn(`putTransfersNotification attempt ${currentAttempt} failed, retrying...`);
+                            if (!operation.retry(new Error('Non-200 response'))) {
+                                resolve();
+                            }
+                        } catch (err) {
+                            this._logger.warn(`putTransfersNotification attempt ${currentAttempt} threw error, retrying...`, err);
+                            if (!operation.retry(err)) {
+                                resolve();
+                            }
+                        }
+                    });
+                });
+
+                if ((res && (res.status !== 200 && res.statusCode !== 200)) && res !== true) {
+                    this._logger.error(`putTransfersNotification failed after ${operation.attempts()} attempts`);
+                }
+            } else {
+                res = await this._backendRequests.putTransfersNotification(this.data, transferId);
+                if ((res && (res.status !== 200 && res.statusCode !== 200)) && res !== true) {
+                    this._logger.error('putTransfersNotification failed');
+                }
+            }
             return res;
         } catch (err) {
             this._logger.isErrorEnabled && this._logger.push({ err, transferId }).error(`Error notifying backend of final transfer state equal to: ${body.transferState}`);

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

@@ -1473,7 +1473,7 @@ class OutboundTransfersModel {
             log.isVerboseEnabled && log.verbose(`Transfer model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
             return this.run();
         } catch (err) {
-            log.isErrorEnabled && log.push({ err }).error(`error running outbound transfer model: ${err?.message}`);
+            log.error('error running outbound transfer model: ', err);
 
             // as this function is recursive, we dont want to error the state machine multiple times
             if (this.data.currentState !== States.ERRORED) {

package/modules/api-svc/test/__mocks__/redis.js

@@ -56,8 +56,11 @@ class RedisClient extends redisMock.RedisClient {
         process.nextTick(() => this.events.emit(...args));
     }
 
-    set(...args) {
-        return promisify(super.set.bind(this))(...args);
+    /**
+     * Note: This Redis mock implementation does not support options like TTL (time-to-live).
+     */
+    set(key, value) {
+        return promisify(super.set.bind(this))(key, value);
     }
 
     get(...args) {

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

@@ -315,7 +315,7 @@ describe('Inbound API handlers transforming incoming ISO20022 message bodies', (
 
         });
 
-        test('calls `prepareTransfer` with the expected arguments.', async () => {
+        test('calls `prepareTransfer` with the expected arguments and sets 200 status.', async () => {
             const transferRequestSpy = jest.spyOn(Model.prototype, 'sendNotificationToPayee');
 
             await expect(handlers['/transfers/{ID}'].patch(mockContext)).resolves.toBe(undefined);
@@ -324,6 +324,8 @@ describe('Inbound API handlers transforming incoming ISO20022 message bodies', (
             expect(transferRequestSpy.mock.calls[0][0]).not.toBeUndefined();
             expect(transferRequestSpy.mock.calls[0][0]).not.toEqual(isoBodies.patchTransfersRequest);
             expect(transferRequestSpy.mock.calls[0][0].transferState).toBe('COMMITTED');
+            expect(mockContext.response.status).toBe(200);
+            console.log('Response body:', mockContext.response);
         });
     });
 

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

@@ -624,12 +624,13 @@ describe('Inbound API handlers:', () => {
             };
         });
 
-        test('calls `model.sendNotificationToPayee with expected arguments', async () => {
+        test('calls `model.sendNotificationToPayee` with expected arguments and responds 200', async () => {
             const notificationSpy = jest.spyOn(Model.prototype, 'sendNotificationToPayee');
 
             await expect(handlers['/transfers/{ID}'].patch(mockNotificationMessage)).resolves.toBe(undefined);
             expect(notificationSpy).toHaveBeenCalledTimes(1);
             expect(notificationSpy.mock.calls[0][1]).toBe(mockNotificationMessage.state.path.params.ID);
+            expect(mockNotificationMessage.response.status).toBe(200);
         });
 
     });
@@ -1075,12 +1076,13 @@ describe('Inbound API handlers:', () => {
             };
         });
 
-        test('calls `model.sendFxPutNotificationToBackend with expected arguments', async () => {
+        test('calls `model.sendFxPutNotificationToBackend` with expected arguments and responds 200', async () => {
             const notificationSpy = jest.spyOn(Model.prototype, 'sendFxPutNotificationToBackend');
 
             await expect(handlers['/fxTransfers/{ID}'].patch(mockNotificationMessage)).resolves.toBe(undefined);
             expect(notificationSpy).toHaveBeenCalledTimes(1);
             expect(notificationSpy.mock.calls[0][1]).toBe(mockNotificationMessage.state.path.params.ID);
+            expect(mockNotificationMessage.response.status).toBe(200);
         });
 
     });