@mojaloop/sdk-scheme-adapter 24.12.0-snapshot.3 → 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.67",
+  "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/InboundServer/handlers.js

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

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

@@ -48,15 +48,17 @@ 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
-        this.sharedAgents = this._createSharedAgents();
+        // 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
@@ -71,7 +73,8 @@ class InboundApi extends EventEmitter {
             cache,
             jwsVerificationKeys: this._jwsVerificationKeys,
             wso2,
-            sharedAgents: this.sharedAgents,
+            backendSharedAgents: this.backendSharedAgents,
+            mojaloopSharedAgents: this.mojaloopSharedAgents,
         });
     }
 
@@ -118,7 +121,7 @@ class InboundApi extends EventEmitter {
         }
     }
 
-    static _SetupApi({ conf, logger, validator, cache, jwsVerificationKeys, wso2, sharedAgents }) {
+    static _SetupApi({ conf, logger, validator, cache, jwsVerificationKeys, wso2, backendSharedAgents, mojaloopSharedAgents }) {
         const api = new Koa();
 
         api.use(middlewares.createErrorHandler(logger));
@@ -130,7 +133,7 @@ class InboundApi extends EventEmitter {
             api.use(middlewares.createJwsValidator(logger, jwsVerificationKeys, jwsExclusions));
         }
 
-        api.use(middlewares.applyState({ conf, cache, wso2, logExcludePaths, sharedAgents }));
+        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());
@@ -160,36 +163,29 @@ class InboundApi extends EventEmitter {
         return keys;
     }
 
-    _createSharedAgents() {
+    _createBackendSharedAgents() {
         const httpAgent = new http.Agent({
             keepAlive: true,
             maxSockets: this._conf.outbound?.maxSockets || 256,
         });
 
-        // Create HTTPS agent based on TLS configuration
-        const httpsAgentOptions = {
+        const httpsAgent = new https.Agent({
             keepAlive: true,
             maxSockets: this._conf.outbound?.maxSockets || 256,
-        };
-
-        // Apply TLS configuration if mTLS is enabled
-        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 with keepAlive enabled for InboundServer');
+        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 });
@@ -199,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,13 +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,
-            sharedAgents: config.sharedAgents
+            sharedAgents: config.backendSharedAgents
         });
 
         this._checkIlp = config.checkIlp;

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.62",
+  "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.62",
+    "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.62",
+  "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.3",
+  "version": "24.12.0-snapshot.4",
   "description": "mojaloop sdk-scheme-adapter",
   "license": "Apache-2.0",
   "homepage": "https://github.com/mojaloop/sdk-scheme-adapter",