@mojaloop/sdk-scheme-adapter 24.12.0-snapshot.2 → 24.12.0-snapshot.4

package/modules/api-svc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter-api-svc",
-  "version": "21.0.0-snapshot.66",
+  "version": "21.0.0-snapshot.68",
   "description": "An adapter for connecting to Mojaloop API enabled switches.",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/modules/api-svc/src/BackendEventHandler/index.js

@@ -56,7 +56,8 @@ class BackendEventHandler {
         this._backendRequests = new BackendRequests({
             logger: this._logger,
             backendEndpoint: config.backendEndpoint,
-            dfspId: config.dfspId
+            dfspId: config.dfspId,
+            sharedAgents: config.sharedAgents
         });
     }
 

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

@@ -76,6 +76,8 @@ const createInboundTransfersModel = (ctx) => new InboundTransfersModel({
     logger: ctx.state.logger,
     wso2: ctx.state.wso2,
     resourceVersions: ctx.resourceVersions,
+    backendSharedAgents: ctx.state.backendSharedAgents,
+    mojaloopSharedAgents: ctx.state.mojaloopSharedAgents,
 });
 
 const prepareResponse = ctx => {

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

@@ -48,13 +48,18 @@ const _validator = new Validate({ logExcludePaths });
 let _initialize;
 
 class InboundApi extends EventEmitter {
-    constructor(conf, logger, cache, validator, wso2) {
+    constructor(conf, logger, cache, validator, wso2, mojaloopSharedAgents) {
         super({ captureExceptions: true });
         this._conf = conf;
         this._cache = cache;
         this._logger = logger;
         _initialize ||= _validator.initialise(apiSpecs, conf);
 
+        // Create shared HTTP and HTTPS agents for backend requests only
+        this.backendSharedAgents = this._createBackendSharedAgents();
+        // Use provided shared Mojaloop agents
+        this.mojaloopSharedAgents = mojaloopSharedAgents;
+
         if (conf.validateInboundJws) {
             // peerJWSKey is a special config option specifically for Payment Manager for Mojaloop
             // that is populated by a management api.
@@ -68,6 +73,8 @@ class InboundApi extends EventEmitter {
             cache,
             jwsVerificationKeys: this._jwsVerificationKeys,
             wso2,
+            backendSharedAgents: this.backendSharedAgents,
+            mojaloopSharedAgents: this.mojaloopSharedAgents,
         });
     }
 
@@ -114,7 +121,7 @@ class InboundApi extends EventEmitter {
         }
     }
 
-    static _SetupApi({ conf, logger, validator, cache, jwsVerificationKeys, wso2 }) {
+    static _SetupApi({ conf, logger, validator, cache, jwsVerificationKeys, wso2, backendSharedAgents, mojaloopSharedAgents }) {
         const api = new Koa();
 
         api.use(middlewares.createErrorHandler(logger));
@@ -126,7 +133,7 @@ class InboundApi extends EventEmitter {
             api.use(middlewares.createJwsValidator(logger, jwsVerificationKeys, jwsExclusions));
         }
 
-        api.use(middlewares.applyState({ conf, cache, wso2, logExcludePaths }));
+        api.use(middlewares.applyState({ conf, cache, wso2, logExcludePaths, backendSharedAgents, mojaloopSharedAgents }));
         api.use(middlewares.createPingMiddleware(conf, jwsVerificationKeys));
         api.use(middlewares.createRequestValidator(validator));
         api.use(middlewares.assignFspiopIdentifier());
@@ -155,10 +162,30 @@ class InboundApi extends EventEmitter {
         }
         return keys;
     }
+
+    _createBackendSharedAgents() {
+        const httpAgent = new http.Agent({
+            keepAlive: true,
+            maxSockets: this._conf.outbound?.maxSockets || 256,
+        });
+
+        const httpsAgent = new https.Agent({
+            keepAlive: true,
+            maxSockets: this._conf.outbound?.maxSockets || 256,
+        });
+
+        this._logger.isInfoEnabled && this._logger.info('Created shared HTTP and HTTPS agents for backend requests');
+
+        return {
+            httpAgent,
+            httpsAgent
+        };
+    }
+
 }
 
 class InboundServer extends EventEmitter {
-    constructor(conf, logger, cache, wso2) {
+    constructor(conf, logger, cache, wso2, mojaloopSharedAgents) {
         super({ captureExceptions: true });
         this._conf = conf;
         this._logger = logger.push({ app: this.constructor.name });
@@ -168,6 +195,7 @@ class InboundServer extends EventEmitter {
             cache,
             _validator,
             wso2,
+            mojaloopSharedAgents,
         );
         this._api.on('error', (...args) => {
             this.emit('error', ...args);

package/modules/api-svc/src/OutboundServer/index.js

@@ -107,32 +107,39 @@ class OutboundApi extends EventEmitter {
 }
 
 class OutboundServer extends EventEmitter {
-    constructor(conf, logger, cache, metricsClient, wso2) {
+    constructor(conf, logger, cache, metricsClient, wso2, mojaloopSharedAgents) {
         super({ captureExceptions: true });
         this._conf = conf;
         this._logger = logger.push({ app: this.constructor.name });
         this._server = null;
 
-        // Create shared HTTP and HTTPS agents to prevent agent recreation per request
-        this._httpAgent = new http.Agent({
-            keepAlive: true,
-            maxSockets: conf.outbound.maxSockets || 256,
-        });
+        // Use provided shared Mojaloop agents or create fallback ones
+        if (mojaloopSharedAgents) {
+            this._httpAgent = mojaloopSharedAgents.httpAgent;
+            this._httpsAgent = mojaloopSharedAgents.httpsAgent;
+            this._logger.isInfoEnabled && this._logger.info('Using shared Mojaloop HTTP and HTTPS agents for OutboundServer');
+        } else {
+            // Fallback: Create shared HTTP and HTTPS agents to prevent agent recreation per request
+            this._httpAgent = new http.Agent({
+                keepAlive: true,
+                maxSockets: conf.outbound.maxSockets || 256,
+            });
+
+            // Create HTTPS agent based on TLS configuration
+            const httpsAgentOptions = {
+                keepAlive: true,
+                maxSockets: conf.outbound.maxSockets || 256,
+            };
+
+            // Apply TLS configuration if mTLS is enabled
+            if (conf.outbound.tls.mutualTLS.enabled && conf.outbound.tls.creds) {
+                Object.assign(httpsAgentOptions, conf.outbound.tls.creds);
+            }
 
-        // Create HTTPS agent based on TLS configuration
-        const httpsAgentOptions = {
-            keepAlive: true,
-            maxSockets: conf.outbound.maxSockets || 256,
-        };
+            this._httpsAgent = new https.Agent(httpsAgentOptions);
 
-        // Apply TLS configuration if mTLS is enabled
-        if (conf.outbound.tls.mutualTLS.enabled && conf.outbound.tls.creds) {
-            Object.assign(httpsAgentOptions, conf.outbound.tls.creds);
+            this._logger.isInfoEnabled && this._logger.info('Created fallback shared HTTP and HTTPS agents with keepAlive enabled');
         }
-
-        this._httpsAgent = new https.Agent(httpsAgentOptions);
-
-        this._logger.isInfoEnabled && this._logger.info('Created shared HTTP and HTTPS agents with keepAlive enabled');
         if (conf.backendEventHandler.enabled) {
             this._eventLogger = new DefaultLogger(BC_CONFIG.bcName, 'backend-api-handler', '0.0.1', conf.logLevel);
             this._eventProducer = new KafkaDomainEventProducer(conf.backendEventHandler.domainEventProducer, this._eventLogger);

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

@@ -27,6 +27,8 @@
 'use strict';
 
 const EventEmitter = require('node:events');
+const http = require('http');
+const https = require('https');
 const _ = require('lodash');
 const { name, version } = require('../../../package.json');
 
@@ -76,6 +78,9 @@ class Server extends EventEmitter {
             logger: this.logger
         });
 
+        // Create shared Mojaloop agents for switch communication (used by both servers)
+        this.mojaloopSharedAgents = this._createMojaloopSharedAgents();
+
         this.wso2 = createAuthClient(conf, logger);
         this.wso2.auth.on('error', (msg) => {
             this.emit('error', 'WSO2 auth error in InboundApi', msg);
@@ -86,6 +91,7 @@ class Server extends EventEmitter {
             this.logger,
             this.cache,
             this.wso2,
+            this.mojaloopSharedAgents,
         );
         this.inboundServer.on('error', (...args) => {
             this.logger.isErrorEnabled && this.logger.push({ args }).error('Unhandled error in Inbound Server');
@@ -98,6 +104,7 @@ class Server extends EventEmitter {
             this.cache,
             this.metricsClient,
             this.wso2,
+            this.mojaloopSharedAgents,
         );
         this.outboundServer.on('error', (...args) => {
             this.logger.isErrorEnabled && this.logger.push({ args }).error('Unhandled error in Outbound Server');
@@ -447,6 +454,33 @@ class Server extends EventEmitter {
             this.fspiopEventHandler?.stop(),
         ]);
     }
+
+    _createMojaloopSharedAgents() {
+        const httpAgent = new http.Agent({
+            keepAlive: true,
+            maxSockets: this.conf.outbound?.maxSockets || 256,
+        });
+
+        // Create HTTPS agent based on TLS configuration for Mojaloop switch communication
+        const httpsAgentOptions = {
+            keepAlive: true,
+            maxSockets: this.conf.outbound?.maxSockets || 256,
+        };
+
+        // Apply TLS configuration if mTLS is enabled for switch communication
+        if (this.conf.outbound?.tls?.mutualTLS?.enabled && this.conf.outbound?.tls?.creds) {
+            Object.assign(httpsAgentOptions, this.conf.outbound.tls.creds);
+        }
+
+        const httpsAgent = new https.Agent(httpsAgentOptions);
+
+        this.logger.isInfoEnabled && this.logger.info('Created shared HTTP and HTTPS agents for Mojaloop switch communication');
+
+        return {
+            httpAgent,
+            httpsAgent
+        };
+    }
 }
 
 /*

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

@@ -57,7 +57,7 @@ class InboundTransfersModel {
         this._getTransferRequestRetry = config.getTransferRequestRetry;
         this._backendRequestRetry = config.backendRequestRetry;
 
-        this._mojaloopRequests = new MojaloopRequests({
+        const mojaloopRequestsConfig = {
             logger: this._logger,
             peerEndpoint: config.peerEndpoint,
             alsEndpoint: config.alsEndpoint,
@@ -78,12 +78,22 @@ class InboundTransfersModel {
             wso2: config.wso2,
             resourceVersions: config.resourceVersions,
             apiType: config.apiType,
-        });
+        };
+
+        // Add shared agents to prevent HTTPS agent recreation per request
+        if (config.mojaloopSharedAgents) {
+            mojaloopRequestsConfig.httpAgent = config.mojaloopSharedAgents.httpAgent;
+            mojaloopRequestsConfig.httpsAgent = config.mojaloopSharedAgents.httpsAgent;
+            this._logger.isDebugEnabled && this._logger.debug('Using shared HTTP/HTTPS agents for InboundTransfersModel MojaloopRequests');
+        }
+
+        this._mojaloopRequests = new MojaloopRequests(mojaloopRequestsConfig);
 
         this._backendRequests = new BackendRequests({
             logger: this._logger,
             backendEndpoint: config.backendEndpoint,
-            dfspId: config.dfspId
+            dfspId: config.dfspId,
+            sharedAgents: config.backendSharedAgents
         });
 
         this._checkIlp = config.checkIlp;

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

@@ -37,7 +37,27 @@ class BackendRequests {
     constructor(config) {
         this.config = config;
         this.logger = config.logger.push({ component: this.constructor.name });
-        this.requester = createHttpRequester({ logger: this.logger });
+
+        // Create HTTP requester with shared agents if available
+        const httpConfig = {
+            timeout: 65000,
+            withCredentials: false,
+            transitional: {
+                clarifyTimeoutError: true,
+            }
+        };
+
+        // Add shared agents to prevent connection recreation per request
+        if (config.sharedAgents) {
+            httpConfig.httpAgent = config.sharedAgents.httpAgent;
+            httpConfig.httpsAgent = config.sharedAgents.httpsAgent;
+            this.logger.isDebugEnabled && this.logger.debug('Using shared HTTP/HTTPS agents for BackendRequests');
+        }
+
+        this.requester = createHttpRequester({
+            logger: this.logger,
+            httpConfig
+        });
 
         // FSPID of THIS DFSP
         this.dfspId = config.dfspId;

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.61",
+  "version": "0.3.0-snapshot.63",
   "description": "Mojaloop sdk scheme adapter command event handler",
   "license": "Apache-2.0",
   "homepage": "https://github.com/mojaloop/sdk-scheme-adapter/",

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.61",
+    "version": "0.3.0-snapshot.63",
     "description": "mojaloop sdk scheme adapter outbound domain event handler",
     "license": "Apache-2.0",
     "homepage": "https://github.com/mojaloop/sdk-scheme-adapter/",

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

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter-private-shared-lib",
-  "version": "0.4.0-snapshot.61",
+  "version": "0.4.0-snapshot.63",
   "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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter",
-  "version": "24.12.0-snapshot.2",
+  "version": "24.12.0-snapshot.4",
   "description": "mojaloop sdk-scheme-adapter",
   "license": "Apache-2.0",
   "homepage": "https://github.com/mojaloop/sdk-scheme-adapter",