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

package/CHANGELOG.md

@@ -1,4 +1,16 @@
 # 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)
 
 

package/docker/k6/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "k6-tests",
+  "version": "1.0.0",
+  "description": "```bash docker run --rm -i grafana/k6 run --vus 1 --duration 10s - <./src/test.js ```",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Eugen Klymniuk",
+  "license": "MIT",
+  "dependencies": {
+    "k6": "0.0.0"
+  },
+  "devDependencies": {
+    "@types/k6": "1.1.1"
+  }
+}

package/docker/k6/src/test.js

@@ -0,0 +1,43 @@
+import http from 'k6/http';
+import { sleep } from 'k6';
+// import { Options } from 'k6/options';
+
+export const options = {
+  vus: 3,
+  iterations: 10,
+  duration: '3s'
+};
+
+// // The default exported function is gonna be picked up by k6 as the entry point for the test script. It will be executed repeatedly in "iterations" for the whole duration of the test.
+// export default function () {
+//   // Make a GET request to the target URL
+//   http.get('https://quickpizza.grafana.com');
+//
+//   // Sleep for 1 second to simulate real-world usage
+//   sleep(1);
+// }
+
+
+// const url = 'http://localhost:4000/parties/MSISDN/1233641534556178';
+const url = 'https://quickpizza.grafana.com/api/put';
+
+export default function () {
+  // const headers = {
+  //   'Content-Type': 'application/json',
+  //   Accept: 'application/vnd.interoperability.iso20022.parties+json;version=2.0'
+  // };
+  // const data = {};
+  const headers = { 'Content-Type': 'application/json' };
+  const data = { name: 'Bert' };
+
+  const res = http.put(url, JSON.stringify(data), { headers });
+
+  let body = {};
+  try {
+    body = JSON.parse(res.body)
+  } catch {}
+
+  console.log(body);
+
+  sleep(0.5)
+}

package/docker-compose.yml

@@ -17,6 +17,7 @@ services:
       - "4000:4000"
       - "4001:4001"
       - "4002:4002"
+      - "4004:4004"
       - "9229:9229"
     depends_on:
       redis:

package/modules/api-svc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter-api-svc",
-  "version": "21.0.0-snapshot.49",
+  "version": "21.0.0-snapshot.52",
   "description": "An adapter for connecting to Mojaloop API enabled switches.",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -96,13 +96,13 @@
     "prom-client": "15.1.3",
     "promise-timeout": "1.3.0",
     "random-word-slugs": "0.1.7",
-    "redis": "5.8.0",
+    "redis": "5.8.1",
     "uuidv4": "6.2.13",
     "ws": "8.18.3"
   },
   "devDependencies": {
-    "@babel/core": "7.28.0",
-    "@babel/preset-env": "7.28.0",
+    "@babel/core": "7.28.3",
+    "@babel/preset-env": "7.28.3",
     "@redocly/openapi-cli": "1.0.0-beta.95",
     "@types/jest": "30.0.0",
     "axios-mock-adapter": "2.1.0",
@@ -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.1",
     "redis-mock": "0.56.3",
     "replace": "1.2.2",
     "standard-version": "9.5.0",

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

@@ -1079,7 +1079,7 @@ const patchFxTransfersById = async (ctx) => {
 
     const model = createInboundTransfersModel(ctx);
 
-    const response = await model.sendFxPatchNotificationToBackend(req.data, idValue);
+    const response = await model.sendFxPutNotificationToBackend(req.data, idValue);
 
     // log the result
     ctx.state.logger.isDebugEnabled && ctx.state.logger.push({response}).

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

@@ -27,6 +27,8 @@
 'use strict';
 
 const redis = require('redis');
+const EventEmitter = require('events');
+const { TimeoutError } = require('./model/common/TimeoutError');
 
 const CONN_ST = {
     CONNECTED: 'CONNECTED',
@@ -41,6 +43,7 @@ const CONN_ST = {
 class Cache {
     constructor(config) {
         this._config = config;
+        this._channelEmitter = new EventEmitter();
 
         if(!config.cacheUrl || !config.logger) {
             throw new Error('Cache config requires cacheUrl and logger properties');
@@ -196,6 +199,109 @@ class Cache {
         return id;
     }
 
+    /**
+     * 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 {number} requestProcessingTimeoutSeconds - Timeout in seconds before rejecting with TimeoutError
+     * @param {boolean} [needParse=true] - Whether to JSON.parse the received message
+     *
+     * @returns {Promise<any>} Promise that resolves with the message or rejects with TimeoutError/Error
+     */
+    async subscribeToOneMessageWithTimerNew(channel, requestProcessingTimeoutSeconds, needParse = true) {
+        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);
+                    }
+                }
+            };
+
+            // 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;
+                }
+            };
+
+            // 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) => {
+                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);
+
+            // Subscribe to Redis channel
+            this._subscriptionClient.subscribe(channel, (msg) => {
+                this._channelEmitter.emit(channel, msg);
+                
+                // Auto-unsubscribe if no more listeners
+                unsubscribeFromRedis('auto-cleanup').catch(err => {
+                    this._logger.push({ channel }).warn('Auto-unsubscribe failed', err);
+                });
+            })
+                .catch(subscribeErr => {
+                    if (isResolved) return;
+                    isResolved = true;
+
+                    cleanup();
+                    this._logger.push({ channel }).error('Failed to subscribe to Redis channel', subscribeErr);
+                    reject(subscribeErr);
+                });
+        });
+    }
+
     /**
      * Subscribes to a channel for some period and always returns resolved promise
      *

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

@@ -953,8 +953,10 @@ class InboundTransfersModel {
         }
     }
 
-    async sendFxPatchNotificationToBackend(body, conversionId) {
+    async sendFxPutNotificationToBackend(body, conversionId) {
+        const log = this._logger.child({ conversionId });
         try {
+            log.verbose('sendFxPutNotificationToBackend payload: ', { body });
             this.data = await this.loadFxState(conversionId);
 
             if(!this.data) {
@@ -974,10 +976,10 @@ class InboundTransfersModel {
 
             await this.saveFxState();
 
-            const res = await this._backendRequests.patchFxTransfersNotification(this.data,conversionId);
+            const res = await this._backendRequests.putFxTransfersNotification(body, conversionId);
             return res;
         } catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err, conversionId }).error(`Error notifying backend of final conversionId state equal to: ${body.conversionState} `);
+            log.error('error in sendFxPutNotificationToBackend: ', err);
         }
     }
     /**

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

@@ -40,6 +40,7 @@ const PartiesModel = require('./PartiesModel');
 const {
     AmountTypes,
     BackendError,
+    TimeoutError,
     CacheKeyPrefixes,
     Directions,
     ErrorMessages,
@@ -321,147 +322,121 @@ class OutboundTransfersModel {
 
             let latencyTimerDone;
 
-            // hook up a subscriber to handle response messages
-            const subId = await this._cache.subscribe(payeeKey, (cn, msg, subId) => {
-                try {
-                    if(latencyTimerDone) {
-                        latencyTimerDone();
-                    }
-                    this.metrics.partyLookupResponses.inc();
-
-                    this.data.getPartiesResponse = JSON.parse(msg);
-                    if (this.data.getPartiesResponse.body?.errorInformation) {
-                        // this is an error response to our GET /parties request
-                        const err = new BackendError(`Got an error response resolving party: ${safeStringify(this.data.getPartiesResponse.body, { depth: Infinity })}`, 500);
-                        err.mojaloopError = this.data.getPartiesResponse.body;
-                        // cancel the timeout handler
-                        clearTimeout(timeout);
-                        return reject(err);
-                    }
-                    let payee = this.data.getPartiesResponse.body;
-
-                    if(!payee.party) {
-                        // we should never get a non-error response without a party, but just in case...
-                        // cancel the timeout handler
-                        clearTimeout(timeout);
-                        return reject(new Error(`Resolved payee has no party object: ${safeStringify(payee)}`));
-                    }
-
-                    payee = payee.party;
-
-                    // cancel the timeout handler
-                    clearTimeout(timeout);
-
-                    this._logger.isVerboseEnabled && this._logger.push({ payee }).verbose('Payee resolved');
+            // now we have a timeout handler and a cache subscriber hooked up we can fire off
+            // a GET /parties request to the switch
+            try {
+                const channel = payeeKey;
+                const subscribing = this._cache.subscribeToOneMessageWithTimerNew(channel, this._requestProcessingTimeoutSeconds);
 
-                    // stop listening for payee resolution messages
-                    // no need to await for the unsubscribe to complete.
-                    // we dont really care if the unsubscribe fails but we should log it regardless
-                    this._cache.unsubscribe(payeeKey, subId, true).catch(e => {
-                        this._logger.isErrorEnabled && this._logger.error(`Error unsubscribing (in callback) ${payeeKey} ${subId}: ${e.stack || safeStringify(e)}`);
-                    });
+                latencyTimerDone = this.metrics.partyLookupLatency.startTimer();
+                const res = await this._requests.getParties(
+                    this.data.to.idType,
+                    this.data.to.idValue,
+                    this.data.to.idSubValue,
+                    this.data.to.fspId,
+                    this.#createOtelHeaders()
+                );
 
-                    // check we got the right payee and info we need
-                    if(payee.partyIdInfo.partyIdType !== this.data.to.idType) {
-                        const err = new Error(`Expecting resolved payee party IdType to be ${this.data.to.idType} but got ${payee.partyIdInfo.partyIdType}`);
-                        return reject(err);
-                    }
+                this.data.getPartiesRequest = res.originalRequest;
 
-                    if(payee.partyIdInfo.partyIdentifier !== this.data.to.idValue) {
-                        const err = new Error(`Expecting resolved payee party identifier to be ${this.data.to.idValue} but got ${payee.partyIdInfo.partyIdentifier}`);
-                        return reject(err);
-                    }
+                this.metrics.partyLookupRequests.inc();
+                this._logger.push({ peer: res }).debug('Party lookup sent to peer');
 
-                    if(payee.partyIdInfo.partySubIdOrType !== this.data.to.idSubValue) {
-                        const err = new Error(`Expecting resolved payee party subTypeId to be ${this.data.to.idSubValue} but got ${payee.partyIdInfo.partySubIdOrType}`);
-                        return reject(err);
-                    }
+                const message = await subscribing;
 
-                    if(!payee.partyIdInfo.fspId) {
-                        const err = new Error(`Expecting resolved payee party to have an FSPID: ${safeStringify(payee.partyIdInfo)}`);
-                        return reject(err);
-                    }
+                if(latencyTimerDone) {
+                    latencyTimerDone();
+                }
+                this.metrics.partyLookupResponses.inc();
 
-                    // now we got the payee, add the details to our data so we can use it
-                    // in the quote request
-                    this.data.to.fspId = payee.partyIdInfo.fspId;
-                    if(payee.partyIdInfo.extensionList) {
-                        this.data.to.extensionList  = payee.partyIdInfo.extensionList.extension;
-                    }
-                    if(payee.personalInfo) {
-                        if(payee.personalInfo.complexName) {
-                            this.data.to.firstName = payee.personalInfo.complexName.firstName || this.data.to.firstName;
-                            this.data.to.middleName = payee.personalInfo.complexName.middleName || this.data.to.middleName;
-                            this.data.to.lastName = payee.personalInfo.complexName.lastName || this.data.to.lastName;
-                        }
-                        this.data.to.dateOfBirth = payee.personalInfo.dateOfBirth;
-                    }
+                this.data.getPartiesResponse = message;
+                if (this.data.getPartiesResponse.body?.errorInformation) {
+                    // this is an error response to our GET /parties request
+                    const err = new BackendError(`Got an error response resolving party: ${safeStringify(this.data.getPartiesResponse.body, { depth: Infinity })}`, 500);
+                    err.mojaloopError = this.data.getPartiesResponse.body;
+                    return reject(err);
+                }
+                let payee = this.data.getPartiesResponse.body;
 
-                    if (Array.isArray(payee.supportedCurrencies)) {
-                        if (!payee.supportedCurrencies.length) {
-                            throw new Error(ErrorMessages.noSupportedCurrencies);
-                        }
+                if(!payee.party) {
+                    // we should never get a non-error response without a party, but just in case...
+                    return reject(new Error(`Resolved payee has no party object: ${safeStringify(payee)}`));
+                }
 
-                        this.data.needFx = this._isFxNeeded(this._supportedCurrencies, payee.supportedCurrencies, this.data.currency, this.data.amountType);
-                        this.data.supportedCurrencies = payee.supportedCurrencies;
-                    }
+                payee = payee.party;
 
-                    this._logger.isVerboseEnabled && this._logger.push({
-                        transferId: this.data.transferId,
-                        homeTransactionId: this.data.homeTransactionId,
-                        needFx: this.data.needFx,
-                    }).verbose('Payee validation passed');
+                this._logger.push({ payee }).verbose('Payee resolved');
 
-                    return resolve(payee);
+                // check we got the right payee and info we need
+                if(payee.partyIdInfo.partyIdType !== this.data.to.idType) {
+                    const err = new Error(`Expecting resolved payee party IdType to be ${this.data.to.idType} but got ${payee.partyIdInfo.partyIdType}`);
+                    return reject(err);
                 }
-                catch (err) {
+
+                if(payee.partyIdInfo.partyIdentifier !== this.data.to.idValue) {
+                    const err = new Error(`Expecting resolved payee party identifier to be ${this.data.to.idValue} but got ${payee.partyIdInfo.partyIdentifier}`);
                     return reject(err);
                 }
-            });
 
-            // set up a timeout for the resolution
-            const timeout = setTimeout(() => {
-                const err = new BackendError(`Timeout resolving payee for transfer ${this.data.transferId}`, 504);
+                if(payee.partyIdInfo.partySubIdOrType !== this.data.to.idSubValue) {
+                    const err = new Error(`Expecting resolved payee party subTypeId to be ${this.data.to.idSubValue} but got ${payee.partyIdInfo.partySubIdOrType}`);
+                    return reject(err);
+                }
 
-                // we dont really care if the unsubscribe fails but we should log it regardless
-                this._cache.unsubscribe(payeeKey, subId, true).catch(e => {
-                    this._logger.isErrorEnabled && this._logger.error(`Error unsubscribing (in timeout handler) ${payeeKey} ${subId}: ${e.stack || safeStringify(e)}`);
-                });
+                if(!payee.partyIdInfo.fspId) {
+                    const err = new Error(`Expecting resolved payee party to have an FSPID: ${safeStringify(payee.partyIdInfo)}`);
+                    return reject(err);
+                }
 
-                if(latencyTimerDone) {
-                    latencyTimerDone();
+                // now we got the payee, add the details to our data so we can use it
+                // in the quote request
+                this.data.to.fspId = payee.partyIdInfo.fspId;
+                if(payee.partyIdInfo.extensionList) {
+                    this.data.to.extensionList  = payee.partyIdInfo.extensionList.extension;
+                }
+                if(payee.personalInfo) {
+                    if(payee.personalInfo.complexName) {
+                        this.data.to.firstName = payee.personalInfo.complexName.firstName || this.data.to.firstName;
+                        this.data.to.middleName = payee.personalInfo.complexName.middleName || this.data.to.middleName;
+                        this.data.to.lastName = payee.personalInfo.complexName.lastName || this.data.to.lastName;
+                    }
+                    this.data.to.dateOfBirth = payee.personalInfo.dateOfBirth;
                 }
 
-                return reject(err);
-            }, this._requestProcessingTimeoutSeconds * 1000);
+                if (Array.isArray(payee.supportedCurrencies)) {
+                    if (!payee.supportedCurrencies.length) {
+                        throw new Error(ErrorMessages.noSupportedCurrencies);
+                    }
 
-            // now we have a timeout handler and a cache subscriber hooked up we can fire off
-            // a GET /parties request to the switch
-            try {
-                latencyTimerDone = this.metrics.partyLookupLatency.startTimer();
-                const res = await this._requests.getParties(
-                    this.data.to.idType,
-                    this.data.to.idValue,
-                    this.data.to.idSubValue,
-                    this.data.to.fspId,
-                    this.#createOtelHeaders()
-                );
+                    this.data.needFx = this._isFxNeeded(this._supportedCurrencies, payee.supportedCurrencies, this.data.currency, this.data.amountType);
+                    this.data.supportedCurrencies = payee.supportedCurrencies;
+                }
 
-                this.data.getPartiesRequest = res.originalRequest;
+                this._logger.push({
+                    transferId: this.data.transferId,
+                    homeTransactionId: this.data.homeTransactionId,
+                    needFx: this.data.needFx,
+                }).verbose('Payee validation passed');
 
-                this.metrics.partyLookupRequests.inc();
-                this._logger.isDebugEnabled && this._logger.push({ peer: res }).debug('Party lookup sent to peer');
+                return resolve(payee);
             }
             catch(err) {
-                // cancel the timeout and unsubscribe before rejecting the promise
-                clearTimeout(timeout);
-
-                // we dont really care if the unsubscribe fails but we should log it regardless
-                this._cache.unsubscribe(payeeKey, subId, true).catch(e => {
-                    this._logger.isErrorEnabled && this._logger.error(`Error unsubscribing ${payeeKey} ${subId}: ${e.stack || safeStringify(e)}`);
-                });
-
-                return reject(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;
+                    return reject(err);
+                }
+                // Check if the error is a TimeoutError, and if so, reject with a BackendError
+                if (err instanceof TimeoutError) {
+                    const error = new BackendError(`Timeout resolving payee for transfer ${this.data.transferId}`, 504);
+                    this.data.lastError = error;
+                    return reject(error);
+                }
+                // otherwise, just throw a generic error
+                const error = new BackendError(`Error resolving payee for transfer ${this.data.transferId}: ${err.message}`, 500);
+                this.data.lastError = error;
+                return reject(error);
             }
         });
     }