@mojaloop/sdk-scheme-adapter 24.10.11 → 24.11.0-snapshot.0

package/modules/api-svc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter-api-svc",
-  "version": "21.0.0-snapshot.57",
+  "version": "21.0.0-snapshot.58",
   "description": "An adapter for connecting to Mojaloop API enabled switches.",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -65,7 +65,7 @@
   "dependencies": {
     "@koa/cors": "5.0.0",
     "@mojaloop/api-snippets": "18.1.1",
-    "@mojaloop/central-services-error-handling": "13.1.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",
@@ -73,7 +73,7 @@
     "@mojaloop/logging-bc-client-lib": "0.5.8",
     "@mojaloop/ml-schema-transformer-lib": "2.7.8",
     "@mojaloop/sdk-scheme-adapter-private-shared-lib": "workspace:^",
-    "@mojaloop/sdk-standard-components": "19.16.9",
+    "@mojaloop/sdk-standard-components": "19.17.0",
     "ajv": "8.17.1",
     "axios": "1.12.2",
     "body-parser": "2.2.0",
@@ -97,6 +97,7 @@
     "promise-timeout": "1.3.0",
     "random-word-slugs": "0.1.7",
     "redis": "5.8.2",
+    "retry": "^0.13.1",
     "uuidv4": "6.2.13",
     "ws": "8.18.3"
   },
@@ -105,6 +106,7 @@
     "@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.1.2",
     "eslint": "9.15.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,60 @@ 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 {
+                        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, 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}`);
@@ -982,7 +1040,47 @@ class InboundTransfersModel {
             };
             log.verbose('sendFxPutNotificationToBackend body sent to cc: ', { responseBody });
 
-            const res = await this._backendRequests.putFxTransfersNotification(responseBody, conversionId);
+            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();
+                            }
+                        }
+                    });
+                });
+
+                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);
@@ -1025,7 +1123,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/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);
         });
 
     });