@mojaloop/sdk-scheme-adapter 24.1.0 → 24.1.1

package/CHANGELOG.md

@@ -1,4 +1,11 @@
 # Changelog: [mojaloop/sdk-scheme-adapter](https://github.com/mojaloop/sdk-scheme-adapter)
+### [24.1.1](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.1.0...v24.1.1) (2025-02-25)
+
+
+### Chore
+
+* **csi-1237:** improved logging ([#546](https://github.com/mojaloop/sdk-scheme-adapter/issues/546)) ([41af8db](https://github.com/mojaloop/sdk-scheme-adapter/commit/41af8dbc23412514a241c635888920ff27edfa6e))
+
 ## [24.1.0](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.0.8...v24.1.0) (2025-02-21)
 
 

package/modules/api-svc/package.json

@@ -68,12 +68,12 @@
     "@mojaloop/central-services-error-handling": "^13.0.6",
     "@mojaloop/central-services-logger": "^11.5.5",
     "@mojaloop/central-services-metrics": "^12.4.5",
-    "@mojaloop/central-services-shared": "^18.18.1",
-    "@mojaloop/event-sdk": "^14.1.4",
+    "@mojaloop/central-services-shared": "^18.18.2",
+    "@mojaloop/event-sdk": "^14.1.5",
     "@mojaloop/logging-bc-client-lib": "0.5.8",
-    "@mojaloop/ml-schema-transformer-lib": "^2.5.3",
+    "@mojaloop/ml-schema-transformer-lib": "^2.5.4",
     "@mojaloop/sdk-scheme-adapter-private-shared-lib": "workspace:^",
-    "@mojaloop/sdk-standard-components": "19.6.6",
+    "@mojaloop/sdk-standard-components": "19.7.0",
     "ajv": "8.17.1",
     "axios": "^1.7.9",
     "body-parser": "^1.20.3",

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

@@ -29,7 +29,6 @@
  ******/
 'use strict';
 
-const safeStringify = require('fast-safe-stringify');
 const {
     AccountsModel,
     OutboundTransfersModel,
@@ -54,7 +53,7 @@ const { ReturnCodes } = Enum.Http;
  * Error handling logic shared by outbound API handlers
  */
 const handleError = (method, err, ctx, stateField) => {
-    ctx.state.logger.isErrorEnabled && ctx.state.logger.error(`Error handling ${method}: ${safeStringify(err)}`);
+    ctx.state.logger.push({ err, stateField }).error(`Error handling ${method}`);
     ctx.response.status = err.httpStatusCode || ReturnCodes.INTERNALSERVERERRROR.CODE;
     ctx.response.body = {
         message: err.message || 'Unspecified error',
@@ -72,6 +71,7 @@ const handleError = (method, err, ctx, stateField) => {
         // the structure of the response object in depth to ascertain an underlying mojaloop API error code.
         const errorInformation = err[stateField].lastError.mojaloopError.errorInformation;
         ctx.response.body.statusCode = errorInformation.errorCode;
+        ctx.state.logger.warn('errorInformation - ', errorInformation);
 
         // if we have been configured to use an error extensionList item as status code, look for it and use
         // it if it is present...
@@ -125,13 +125,21 @@ const handleRequestSimpleTransfersInformationError = (method, err, ctx) =>
 
 const createOutboundTransfersModel = (ctx) => new OutboundTransfersModel({
     ...ctx.state.conf,
-    ...ctx.state.path?.params?.dfspId && {dfspId: ctx.state.path.params.dfspId},
+    ...(ctx.state.path?.params?.dfspId && { dfspId: ctx.state.path.params.dfspId }),
     cache: ctx.state.cache,
     logger: ctx.state.logger,
     wso2: ctx.state.wso2,
     metricsClient: ctx.state.metricsClient,
 });
 
+const createOutboundBulkTransfersModel = (ctx) => new OutboundBulkTransfersModel({
+    ...ctx.state.conf,
+    ...(ctx.state.path?.params?.dfspId && { dfspId: ctx.state.path.params.dfspId }),
+    cache: ctx.state.cache,
+    logger: ctx.state.logger,
+    wso2: ctx.state.wso2,
+});
+
 /**
  * Handler for outbound transfer request initiation
  */
@@ -222,13 +230,7 @@ const postBulkTransfers = async (ctx) => {
         };
 
         // use the bulk transfers model to execute asynchronous stages with the switch
-        const model = new OutboundBulkTransfersModel({
-            ...ctx.state.conf,
-            ...ctx.state.path?.params?.dfspId && {dfspId: ctx.state.path.params.dfspId},
-            cache: ctx.state.cache,
-            logger: ctx.state.logger,
-            wso2: ctx.state.wso2,
-        });
+        const model = createOutboundBulkTransfersModel(ctx);
 
         await model.initialize(bulkTransferRequest);
         const response = await model.run();
@@ -254,13 +256,7 @@ const getBulkTransfers = async (ctx) => {
         };
 
         // use the bulk transfers model to execute asynchronous stages with the switch
-        const model = new OutboundBulkTransfersModel({
-            ...ctx.state.conf,
-            ...ctx.state.path?.params?.dfspId && {dfspId: ctx.state.path.params.dfspId},
-            cache: ctx.state.cache,
-            logger: ctx.state.logger,
-            wso2: ctx.state.wso2,
-        });
+        const model = createOutboundBulkTransfersModel(ctx);
 
         await model.initialize(bulkTransferRequest);
         const response = await model.getBulkTransfer();

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

@@ -26,10 +26,11 @@
  ******/
 'use strict';
 
-const fs = require('fs');
 require('dotenv').config();
+const fs = require('node:fs');
 const yaml = require('js-yaml');
 const { from } = require('env-var');
+const { Logger } = require('@mojaloop/sdk-standard-components').Logger;
 const { API_TYPES, RESOURCE_VERSIONS_STRING } = require('./constants');
 
 function getFileContent (path) {
@@ -88,7 +89,7 @@ module.exports = {
         mgmtAPIWsPort: env.get('MGMT_API_WS_PORT').default('4005').asPortNumber()
     },
     idGenerator: env.get('ID_GENERATOR').default('{"type":"ulid"}').asJsonObject(),
-    logLevel: env.get('LOG_LEVEL').default('info').asEnum(['trace', 'debug', 'info', 'warn', 'error', 'fatal']),
+    logLevel: env.get('LOG_LEVEL').default('info').asEnum(Logger.logLevels),
     inbound: {
         port: env.get('INBOUND_LISTEN_PORT').default('4000').asPortNumber(),
         tls: {

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

@@ -376,9 +376,9 @@ class Server extends EventEmitter {
 async function _GetUpdatedConfigFromMgmtAPI(conf, logger, client) {
     logger.isInfoEnabled && logger.info(`Getting updated config from Management API at ${conf.control.mgmtAPIWsUrl}:${conf.control.mgmtAPIWsPort}...`);
     const clientSendResponse = await client.send(ControlAgent.build.CONFIGURATION.READ());
-    logger.isInfoEnabled && logger.info('client send returned:: ', clientSendResponse);
+    logger.isDebugEnabled && logger.debug('client send returned:: ', clientSendResponse);
     const responseRead = await client.receive();
-    logger.isInfoEnabled && logger.info('client receive returned:: ', responseRead);
+    logger.isDebugEnabled && logger.debug('client receive returned:: ', responseRead);
     return responseRead.data;
 }
 
@@ -387,13 +387,13 @@ async function start(config) {
 
     if (config.pm4mlEnabled) {
         const controlClient = await ControlAgent.Client.Create({
+            appConfig: config,
             address: config.control.mgmtAPIWsUrl,
             port: config.control.mgmtAPIWsPort,
-            logger: logger,
-            appConfig: config,
+            logger,
         });
         const updatedConfigFromMgmtAPI = await _GetUpdatedConfigFromMgmtAPI(config, logger, controlClient);
-        logger.isInfoEnabled && logger.push({ updatedConfigFromMgmtAPI }).info('updatedConfigFromMgmtAPI:');
+        logger.isInfoEnabled && logger.push({ updatedConfigFromMgmtAPIKeys: Object.keys(updatedConfigFromMgmtAPI) }).info('updatedConfigFromMgmtAPI keys:');
         _.merge(config, updatedConfigFromMgmtAPI);
         controlClient.terminate();
     }

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

@@ -122,11 +122,10 @@ class InboundTransfersModel {
             return this._mojaloopRequests.putAuthorizations(transactionRequestId, mlAuthorization, sourceFspId);
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getOTP');
+            this._logger.isErrorEnabled && this._logger.push({ err, transactionRequestId }).error('Error in getOTP');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
-            return this._mojaloopRequests.putAuthorizationsError(transactionRequestId,
-                mojaloopError, sourceFspId);
+            return this._mojaloopRequests.putAuthorizationsError(transactionRequestId, mojaloopError, sourceFspId);
         }
     }
 
@@ -148,7 +147,7 @@ class InboundTransfersModel {
                 sourceFspId);
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getParticipants');
+            this._logger.isErrorEnabled && this._logger.push({ err, idValue }).error('Error in getParticipants');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putParticipantsError(idType, idValue, idSubValue,
@@ -189,7 +188,7 @@ class InboundTransfersModel {
 
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getParties');
+            this._logger.isErrorEnabled && this._logger.push({ err, idValue }).error('Error in getParties');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putPartiesError(idType, idValue, idSubValue,
@@ -318,7 +317,7 @@ class InboundTransfersModel {
             await this._backendRequests.putRequestToPayNotification(internalForm, transactionRequestId);
         }
         catch(err) {
-            this._logger.push({ err }).error('Error in putTransactionRequest');
+            this._logger.push({ err, transactionRequestId }).error('Error in putTransactionRequest');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return await this._mojaloopRequests.putQuotesError(transactionRequestId,
@@ -339,19 +338,17 @@ class InboundTransfersModel {
             if (!quoteResponse) {
                 const err = new Error('Quote Id not found');
                 const mojaloopError = await this._handleError(err, Errors.MojaloopApiErrorCodes.QUOTE_ID_NOT_FOUND);
-                this._logger.push({ mojaloopError }).error(`Sending error response to ${sourceFspId}`);
-                return await this._mojaloopRequests.putQuotesError(quoteId,
-                    mojaloopError, sourceFspId);
+                this._logger.push({ mojaloopError, quoteId }).warn(`Sending error response to ${sourceFspId}`);
+                return await this._mojaloopRequests.putQuotesError(quoteId, mojaloopError, sourceFspId);
             }
             // Make a PUT /quotes/{ID} callback to the source fsp with the quote response
             return this._mojaloopRequests.putQuotes(quoteId, quoteResponse, sourceFspId);
         }
         catch(err) {
-            this._logger.push({ err }).error('Error in getQuoteRequest');
+            this._logger.push({ err, quoteId }).error('Error in getQuoteRequest');
             const mojaloopError = await this._handleError(err);
-            this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
-            return await this._mojaloopRequests.putQuotesError(quoteId,
-                mojaloopError, sourceFspId);
+            this._logger.isVerboseEnabled && this._logger.push({ mojaloopError }).verbose(`Sending error response to ${sourceFspId}`);
+            return await this._mojaloopRequests.putQuotesError(quoteId, mojaloopError, sourceFspId);
         }
     }
 
@@ -378,7 +375,7 @@ class InboundTransfersModel {
             return this._mojaloopRequests.putTransactionRequests(transactionRequest.transactionRequestId, mojaloopResponse, sourceFspId);
         }
         catch(err) {
-            this._logger.push({ err }).error('Error in transactionRequest');
+            this._logger.push({ err }).error(`Error in transactionRequest ${transactionRequest?.transactionRequestId}`);
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putTransactionRequestsError(transactionRequest.transactionRequestId,
@@ -491,7 +488,7 @@ class InboundTransfersModel {
             await this._save();
             return res;
         } catch(err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in prepareTransfer');
+            this._logger.isErrorEnabled && this._logger.push({ err }).error(`Error in prepareTransfer: ${request?.body?.transferId}`);
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return await this._mojaloopRequests.putTransfersError(prepareRequest.transferId,
@@ -548,7 +545,7 @@ class InboundTransfersModel {
                 sourceFspId);
         }
         catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getTransfers');
+            this._logger.isErrorEnabled && this._logger.push({ err, transferId }).error('Error in getTransfers');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putTransfersError(transferId,
@@ -773,7 +770,7 @@ class InboundTransfersModel {
                 sourceFspId);
         }
         catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getBulkQuote');
+            this._logger.isErrorEnabled && this._logger.push({ err, bulkQuoteId }).error('Error in getBulkQuote');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putBulkQuotesError(bulkQuoteId,
@@ -951,7 +948,7 @@ class InboundTransfersModel {
                 sourceFspId);
         }
         catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getBulkTransfer');
+            this._logger.isErrorEnabled && this._logger.push({ err, bulkTransferId }).error('Error in getBulkTransfer');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putBulkTransfersError(bulkTransferId,
@@ -983,7 +980,7 @@ class InboundTransfersModel {
             const res = await this._backendRequests.patchFxTransfersNotification(this.data,conversionId);
             return res;
         } catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error(`Error notifying backend of final conversionId state equal to: ${body.conversionState} `);
+            this._logger.isErrorEnabled && this._logger.push({ err, conversionId }).error(`Error notifying backend of final conversionId state equal to: ${body.conversionState} `);
         }
     }
     /**
@@ -1022,7 +1019,7 @@ class InboundTransfersModel {
             const res = await this._backendRequests.putTransfersNotification(this.data, transferId);
             return res;
         } catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error(`Error notifying backend of final transfer state equal to: ${body.transferState}`);
+            this._logger.isErrorEnabled && this._logger.push({ err, transferId }).error(`Error notifying backend of final transfer state equal to: ${body.transferState}`);
         }
     }
 
@@ -1097,7 +1094,7 @@ class InboundTransfersModel {
             return data;
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error loading transfer model');
+            this._logger.isErrorEnabled && this._logger.push({ err, transferId }).error('Error loading transfer model');
             throw err;
         }
     }
@@ -1105,13 +1102,13 @@ class InboundTransfersModel {
     async saveFxState() { // fxQuote + fxTransfer
         const key = this.makeFxQuoteCacheKey(this.data?.conversionId);
         const res = await this._cache.set(key, this.data, this._cacheTtl);
-        this._logger.push({ key, res }).log('fxState is saved in cache');
+        this._logger.push({ key, res }).debug('fxState is saved in cache');
     }
 
     async loadFxState(conversionId) {
         const key = this.makeFxQuoteCacheKey(conversionId);
         const data = await this._cache.get(key);
-        this._logger.push({ key, data }).log('fxState is loaded from cache');
+        this._logger.push({ key, data }).debug('fxState is loaded from cache');
         return data;
     }
 

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

@@ -455,43 +455,44 @@ class OutboundBulkQuotesModel {
      * Returns a promise that resolves when the state machine has reached a terminal state
      */
     async run() {
+        const log = this._logger.push({ bulkQuoteId: this.data.bulkQuoteId });
         try {
             // run transitions based on incoming state
             switch(this.data.currentState) {
                 case 'start':
                     await this.stateMachine.requestBulkQuote();
-                    this._logger.isDebugEnabled && this._logger.debug(`Quotes resolved for bulk quote ${this.data.bulkQuoteId}`);
+                    log.isInfoEnabled && log.info('Quotes resolved for bulk quote');
                     break;
 
                 case 'getBulkQuote':
                     await this.stateMachine.getBulkQuote();
-                    this._logger.isDebugEnabled && this._logger.debug(`Get bulk quote ${this.data.bulkQuoteId} has been completed`);
+                    log.isInfoEnabled && log.info('Get bulk quote has been completed');
                     break;
 
                 case 'succeeded':
                     // all steps complete so return
-                    this._logger.isDebugEnabled && this._logger.debug('Bulk quoting completed successfully');
+                    log.isInfoEnabled && log.info('Bulk quoting completed successfully');
                     await this._save();
                     return this.getResponse();
 
                 case 'errored':
                     // stopped in errored state
-                    this._logger.isErrorEnabled && this._logger.error('State machine in errored state');
+                    log.isWarnEnabled && log.warn('State machine in errored state');
                     return;
             }
 
             // now call ourselves recursively to deal with the next transition
-            this._logger.isDebugEnabled && this._logger.debug(`Bulk quote model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
+            log.isVerboseEnabled && log.verbose(`Bulk quote model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
             return this.run();
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.error(`Error running bulk quote model: ${safeStringify(err)}`);
+            log.isErrorEnabled && log.push({ err }).error(`Error running bulk quote model: ${err?.message}`);
 
             // as this function is recursive, we dont want to error the state machine multiple times
             if(this.data.currentState !== 'errored') {
                 // err should not have a bulkQuoteState property here!
                 if(err.bulkQuoteState) {
-                    this._logger.isErrorEnabled && this._logger.error(`State machine is broken: ${safeStringify(err)}`);
+                    log.isWarnEnabled && log.warn('State machine is broken');
                 }
                 // transition to errored state
                 await this.stateMachine.error(err);

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

@@ -448,43 +448,44 @@ class OutboundBulkTransfersModel {
      * Returns a promise that resolves when the state machine has reached a terminal state
      */
     async run() {
+        const log = this._logger.push({ bulkTransferId: this.data.bulkTransferId });
         try {
             // run transitions based on incoming state
             switch(this.data.currentState) {
                 case 'start':
                     await this.stateMachine.executeBulkTransfer();
-                    this._logger.isDebugEnabled && this._logger.debug(`Bulk transfer ${this.data.bulkTransferId} has been completed`);
+                    log.isInfoEnabled && log.info('Bulk transfer has been started');
                     break;
 
                 case 'getBulkTransfer':
                     await this.stateMachine.getBulkTransfer();
-                    this._logger.isDebugEnabled && this._logger.debug(`Get bulk transfer ${this.data.bulkTransferId} has been completed`);
+                    log.isInfoEnabled && log.info('Get bulk transfer has been completed');
                     break;
 
                 case 'succeeded':
                     // all steps complete so return
-                    this._logger.isDebugEnabled && this._logger.debug('Bulk transfer completed successfully');
+                    log.isInfoEnabled && log.info('Bulk transfer completed successfully');
                     await this._save();
                     return this.getResponse();
 
                 case 'errored':
                     // stopped in errored state
-                    this._logger.isErrorEnabled && this._logger.error('State machine in errored state');
+                    log.isWarnEnabled && log.warn('State machine in errored state');
                     return;
             }
 
             // now call ourselves recursively to deal with the next transition
-            this._logger.isDebugEnabled && this._logger.debug(`Bulk transfer model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
+            log.isVerboseEnabled && log.verbose(`Bulk transfer model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
             return this.run();
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.error(`Error running transfer model: ${safeStringify(err)}`);
+            log.isErrorEnabled && log.push({ err }).error(`Error running bulk transfer model: ${err.message}`);
 
             // as this function is recursive, we dont want to error the state machine multiple times
             if(this.data.currentState !== 'errored') {
                 // err should not have a bulkTransferState property here!
                 if(err.bulkTransferState) {
-                    this._logger.isErrorEnabled && this._logger.error(`State machine is broken: ${safeStringify(err)}`);
+                    log.isWarnEnabled && log.warn('State machine is broken');
                 }
                 // transition to errored state
                 await this.stateMachine.error(err);

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

@@ -426,16 +426,19 @@ class OutboundRequestToPayModel {
      * Returns a promise that resolves when the state machine has reached a terminal state
      */
     async run() {
+        const { transferId, transactionRequestId } = this.data;
+        const log = this._logger.push({ transferId, transactionRequestId });
         try {
             // run transitions based on incoming state
             switch(this.data.currentState) {
                 case 'start':
                     // next transition is to resolvePayee
                     await this.stateMachine.resolvePayee();
-                    this._logger.isDebugEnabled && this._logger.debug(`Payee resolved for transfer ${this.data.transferId}`);
+                    log.isInfoEnabled && log.info('Payee resolved for RequestToPay transfer');
                     if(this.stateMachine.state === 'payeeResolved' && !this._autoAcceptR2PParty) {
                         //we break execution here and return the resolved party details to allow asynchronous accept or reject
                         //of the resolved party
+                        log.isInfoEnabled && log.info('Waiting for asynchronous accept or reject of resolved party');
                         await this._save();
                         return this.getResponse();
                     }
@@ -444,12 +447,12 @@ class OutboundRequestToPayModel {
                 case 'payeeResolved':
                     // next transition is to requestQuote
                     await this.stateMachine.executeTransactionRequest();
-                    this._logger.isDebugEnabled && this._logger.debug(`Transaction Request for ${this.data.transactionRequestId} has been completed`);
+                    log.isInfoEnabled && log.info('Transaction Request has been completed');
                     break;
 
                 case 'succeeded':
                     // all steps complete so return
-                    this._logger.isDebugEnabled && this._logger.debug('Transaction Request completed successfully');
+                    log.isInfoEnabled && log.info('Transaction Request completed successfully');
                     await this._save();
                     return this.getResponse();
 
@@ -460,17 +463,17 @@ class OutboundRequestToPayModel {
             }
 
             // now call ourselves recursively to deal with the next transition
-            this._logger.isDebugEnabled && this._logger.debug(`Transfer model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
+            log.isVerboseEnabled && log.verbose(`RequestToPay model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
             return this.run();
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.error(`Error running transfer model: ${safeStringify(err)}`);
+            log.isErrorEnabled && log.error(`Error running RequestToPay model: ${err?.message}`);
 
             // as this function is recursive, we dont want to error the state machine multiple times
             if(this.data.currentState !== 'errored') {
                 // err should not have a lastError property here!
                 if(err.lastError) {
-                    this._logger.isErrorEnabled && this._logger.error(`State machine is broken: ${safeStringify(err)}`);
+                    log.isWarnEnabled && log.warn('State machine is broken');
                 }
                 // transition to errored state
                 await this.stateMachine.error(err);

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

@@ -210,7 +210,7 @@ class OutboundTransfersModel {
      * Updates the internal state representation to reflect that of the state machine itself
      */
     _afterTransition() {
-        this._logger.isDebugEnabled && this._logger.debug(`State machine transitioned: ${this.data.currentState} -> ${this.stateMachine.state}`);
+        this._logger.isVerboseEnabled && this._logger.verbose(`State machine transitioned: ${this.data.currentState} -> ${this.stateMachine.state} for transfer ${this.data.transferId}`);
         this.data.currentState = this.stateMachine.state;
     }
 
@@ -348,7 +348,7 @@ class OutboundTransfersModel {
                     // cancel the timeout handler
                     clearTimeout(timeout);
 
-                    this._logger.isDebugEnabled && this._logger.push({ payee }).debug('Payee resolved');
+                    this._logger.isVerboseEnabled && this._logger.push({ payee }).verbose('Payee resolved');
 
                     // stop listening for payee resolution messages
                     // no need to await for the unsubscribe to complete.
@@ -392,7 +392,7 @@ class OutboundTransfersModel {
                         }
                         this.data.to.dateOfBirth = payee.personalInfo.dateOfBirth;
                     }
-                    
+
                     if (Array.isArray(payee.supportedCurrencies)) {
                         if (!payee.supportedCurrencies.length) {
                             throw new Error(ErrorMessages.noSupportedCurrencies);
@@ -586,7 +586,7 @@ class OutboundTransfersModel {
                 body: payload,
                 headers: originalRequest.headers
             };
-            this._logger.debug('fxQuote request is sent to hub');
+            this._logger.isVerboseEnabled && this._logger.push({ fxQuotePayload: payload }).verbose('fxQuote request is sent to hub');
 
             const message = await subscribing;
 
@@ -665,7 +665,7 @@ class OutboundTransfersModel {
                         error.mojaloopError = message.data.body;
                     }
                     else {
-                        this._logger.isDebugEnabled && this._logger.push({ message }).debug(`Ignoring cache notification for quote ${quoteKey}. Unknown message type ${message.type}.`);
+                        this._logger.isVerboseEnabled && this._logger.push({ quoteKey, message }).verbose(`Ignoring cache notification for quote ${quoteKey}. Unknown message type ${message.type}.`);
                         return;
                     }
 
@@ -689,7 +689,7 @@ class OutboundTransfersModel {
                         body: message.data.body,
                         originalIso20022QuoteResponse: message.data.originalIso20022QuoteResponse,
                     };
-                    this._logger.push({ quoteResponse: this.data.quoteResponse.body }).debug('Quote response received');
+                    this._logger.isVerboseEnabled && this._logger.push({ quoteResponse: this.data.quoteResponse.body }).verbose('Quote response received');
 
                     this.data.quoteResponseSource = this.data.quoteResponse.headers['fspiop-source'];
 
@@ -897,7 +897,7 @@ class OutboundTransfersModel {
                         error = new BackendError(`Got an error response preparing transfer: ${safeStringify(message.data.body, { depth: Infinity })}`, 500);
                         error.mojaloopError = message.data.body;
                     } else {
-                        this._logger.isDebugEnabled && this._logger.push({ message }).debug(`Ignoring cache notification for transfer ${transferKey}. Unknown message type ${message.type}.`);
+                        this._logger.isVerboseEnabled && this._logger.push({ message }).verbose(`Ignoring cache notification for transfer ${transferKey}. Unknown message type ${message.type}.`);
                         return;
                     }
 
@@ -914,7 +914,7 @@ class OutboundTransfersModel {
                     }
 
                     const fulfil = message.data;
-                    this._logger.isDebugEnabled && this._logger.push({ fulfil: fulfil.body }).debug('Transfer fulfil received');
+                    this._logger.isInfoEnabled && this._logger.push({ fulfil: fulfil.body }).info('Transfer fulfil received');
                     this.data.fulfil = fulfil;
                     if(this._checkIlp && !this._ilp.validateFulfil(fulfil.body.fulfilment, this.data.quoteResponse.body.condition)) {
                         throw new Error('Invalid fulfilment received from peer DFSP.');
@@ -934,7 +934,7 @@ class OutboundTransfersModel {
                         const res = this._requests.patchTransfers(this.data.transferId,
                             patchNotification, this.data.quoteResponseSource);
                         this.data.patch = res.originalRequest;
-                        this._logger.isDebugEnabled && this._logger.debug(`PATCH final notification sent to peer for transfer ${this.data.transferId}`);
+                        this._logger.isInfoEnabled && this._logger.info(`PATCH final notification sent to peer for transfer ${this.data.transferId}`);
                     }
                     return resolve(fulfil.body);
                 }
@@ -980,7 +980,7 @@ class OutboundTransfersModel {
                 };
 
                 this.metrics.transferPrepares.inc();
-                this._logger.isDebugEnabled && this._logger.push({ res }).debug('Transfer prepare sent to peer');
+                this._logger.isVerboseEnabled && this._logger.push({ prepare, res }).verbose('Transfer prepare sent to peer');
             }
             catch(err) {
                 // cancel the timeout and unsubscribe before rejecting the promise
@@ -1013,7 +1013,7 @@ class OutboundTransfersModel {
                         error = new BackendError(`Got an error response retrieving transfer: ${safeStringify(message.data.body, { depth: Infinity })}`, 500);
                         error.mojaloopError = message.data.body;
                     } else if (message.type !== 'transferFulfil') {
-                        this._logger.isDebugEnabled && this._logger.push({ message }).debug(`Ignoring cache notification for transfer ${transferKey}. Uknokwn message type ${message.type}.`);
+                        this._logger.isVerboseEnabled && this._logger.push({ message }).verbose(`Ignoring cache notification for transfer ${transferKey}. Unknown message type ${message.type}.`);
                         return;
                     }
                     // cancel the timeout handler
@@ -1026,7 +1026,7 @@ class OutboundTransfersModel {
                         return reject(error);
                     }
                     const fulfil = message.data;
-                    this._logger.isDebugEnabled && this._logger.push({ fulfil: fulfil.body }).debug('Transfer fulfil received');
+                    this._logger.isVerboseEnabled && this._logger.push({ fulfil: fulfil.body }).verbose('Transfer fulfil received');
                     this.data.fulfil = fulfil;
                     return resolve(this.data.fulfil);
                 }
@@ -1051,7 +1051,7 @@ class OutboundTransfersModel {
             // a GET /transfers request to the switch
             try {
                 const res = await this._requests.getTransfers(this.data.transferId);
-                this._logger.isDebugEnabled && this._logger.push({ peer: res }).debug('Transfer lookup sent to peer');
+                this._logger.isVerboseEnabled && this._logger.push({ peer: res }).verbose(`getTransfers ${this.data.transferId} sent to peer`);
             }
             catch(err) {
                 // cancel the timout and unsubscribe before rejecting the promise
@@ -1114,7 +1114,7 @@ class OutboundTransfersModel {
                     'CdtTrfTxInf.InstrForCdtrAgt.',
                     'CdtTrfTxInf.InstrForNxtAgt.'
                 ];
-                const filteredExtensions = quoteResponseExtensions.filter(ext => 
+                const filteredExtensions = quoteResponseExtensions.filter(ext =>
                     prefixes.some(prefix => ext.key.startsWith(prefix))
                 );
                 if (filteredExtensions.length > 0) {
@@ -1236,7 +1236,7 @@ class OutboundTransfersModel {
 
     /**
      * Determines if FX is needed for the transfer
-     * 
+     *
      * @param {Array} payerCurrencies - Array of supported currencies for the payer
      * @param {Array} payeeCurrencies - Array of supported currencies for the payee
      * @param {string} amountCurrency - Currency of the amount being transferred
@@ -1291,6 +1291,8 @@ class OutboundTransfersModel {
      * @param mergeData {object} - an object to merge with the model state (data) before running the state machine
      */
     async run(mergeData = null) {
+        const log = this._logger.push({ transferId: this.data?.transferId });
+
         try {
             // if we were passed a mergeData object...
             // merge it with our existing state, overwriting any existing matching root level keys
@@ -1317,7 +1319,7 @@ class OutboundTransfersModel {
 
                     if (typeof(this.data.to.fspId) !== 'undefined' && this.data.skipPartyLookup) {
                         // we already have the payee DFSP and we have bee asked to skip party resolution
-                        this._logger.isDebugEnabled && this._logger.debug(`Skipping payee resolution for transfer ${this.data.transferId} as to.fspId was provided and skipPartyLookup is truthy`);
+                        log.isInfoEnabled && log.info('Skipping payee resolution for transfer as to.fspId was provided and skipPartyLookup is truthy');
                         this.data.currentState = States.PAYEE_RESOLVED;
                         // (!) this.data.currentState and this.stateMachine.state are different now!
                         break;
@@ -1325,10 +1327,10 @@ class OutboundTransfersModel {
 
                     // next transition is to resolvePayee
                     await this.stateMachine.resolvePayee();
-                    this._logger.isDebugEnabled && this._logger.debug(`Payee resolved for transfer ${this.data.transferId}`);
+                    log.isInfoEnabled && log.info('Payee resolved for transfer');
 
                     if (this.stateMachine.state === States.PAYEE_RESOLVED && !this._autoAcceptParty) {
-                        this._logger.isDebugEnabled && this._logger.debug(`Transfer ${this.data.transferId} waits for async acceptParty`);
+                        log.isInfoEnabled && log.info('Transfer waits for async acceptParty');
                         await this._save();
                         return this.getResponse();
                     }
@@ -1337,20 +1339,23 @@ class OutboundTransfersModel {
                 case States.PAYEE_RESOLVED:
                     if (!this._autoAcceptParty && !this.data.acceptParty && !this.data.skipPartyLookup) {
                         // resuming after a party resolution halt, backend did not accept the party.
-                        await this.stateMachine.abort('Payee rejected by backend');
+                        const abortMessage = 'Payee rejected by backend';
+                        log.isInfoEnabled && log.info(abortMessage);
+                        await this.stateMachine.abort(abortMessage);
                         await this._save();
                         return this.getResponse();
                     }
 
                     if (this.data.needFx) {
                         await this.stateMachine.requestServicesFxp();
-                        this._logger.verbose(`Services FXP received for transfer ${this.data.transferId}`);
+                        log.isInfoEnabled && log.info('Services FXP received for transfer');
                     } else {
                         await this.stateMachine.requestQuote();
-                        this._logger.verbose(`Quote received for transfer ${this.data.transferId}`);
+                        log.isInfoEnabled && log.info('Quote received for transfer');
                         if (this.stateMachine.state === States.QUOTE_RECEIVED && !this._autoAcceptQuotes) {
                             //we break execution here and return the quote response details to allow asynchronous accept or reject
                             //of the quote
+                            log.isInfoEnabled && log.info('Transfer waits for async accept or reject of quotes');
                             await this._save();
                             return this.getResponse();
                         }
@@ -1363,11 +1368,11 @@ class OutboundTransfersModel {
                         : Transitions.REQUEST_QUOTE;
 
                     await this.stateMachine[transition]();
-                    this._logger.verbose(`${transition} for transfer ${this.data.transferId} has been completed`);
+                    log.isInfoEnabled && log.info(`Transition ${transition} for transfer has been completed`);
 
                     if ([States.QUOTE_RECEIVED, States.FX_QUOTE_RECEIVED].includes(this.stateMachine.state)) {
                         //we break execution here and return the quotes/fxQuote response details to allow asynchronous accept or reject
-                        this._logger.isDebugEnabled && this._logger.debug(`Transfer ${this.data.transferId} waits for async accept or reject`);
+                        log.isInfoEnabled && log.info(`Transfer waits for async accept or reject of ${transition}`);
                         await this._save();
                         return this.getResponse();
                     }
@@ -1378,7 +1383,9 @@ class OutboundTransfersModel {
                     if ((this.data.acceptConversion !== undefined && this.data.acceptConversion === false) ||
                         (this.data.acceptQuoteOrConversion !== undefined && this.data.acceptQuoteOrConversion === false) ||
                         (this.data.acceptConversion === undefined && this.data.acceptQuoteOrConversion === undefined)) {
-                        await this.stateMachine.abort(ErrorMessages.fxQuoteRejectedByBackend);
+                        const abortMessage = ErrorMessages.fxQuoteRejectedByBackend;
+                        log.isInfoEnabled && log.info(abortMessage);
+                        await this.stateMachine.abort(abortMessage);
                         await this._save();
                         return this.getResponse();
                     }
@@ -1388,10 +1395,10 @@ class OutboundTransfersModel {
                         : Transitions.EXECUTE_FX_TRANSFER;
 
                     await this.stateMachine[transition]();
-                    this._logger.isVerboseEnabled && this._logger.verbose(`${transition} for transfer ${this.data.transferId} is done`);
+                    log.isInfoEnabled && log.info(`Transition ${transition} for transfer is done`);
 
                     if (this.stateMachine.state === States.QUOTE_RECEIVED && !this._autoAcceptQuotes) {
-                        this._logger.isDebugEnabled && this._logger.debug(`Transfer ${this.data.transferId} waits for async acceptQuotes`);
+                        log.isInfoEnabled && log.info('Transfer waits for async acceptQuotes');
                         await this._save();
                         return this.getResponse();
                     }
@@ -1404,7 +1411,9 @@ class OutboundTransfersModel {
                         (this.data.acceptQuoteOrConversion !== undefined && this.data.acceptQuoteOrConversion === false) ||
                         (this.data.acceptQuote === undefined && this.data.acceptQuoteOrConversion === undefined))) {
                         // resuming after a party resolution halt, backend did not accept the party.
-                        await this.stateMachine.abort(ErrorMessages.quoteRejectedByBackend);
+                        const abortMessage = ErrorMessages.quoteRejectedByBackend;
+                        log.isInfoEnabled && log.info(abortMessage);
+                        await this.stateMachine.abort(abortMessage);
                         await this._save();
                         return this.getResponse();
                     }
@@ -1416,10 +1425,10 @@ class OutboundTransfersModel {
                             : Transitions.REQUEST_FX_QUOTE);
 
                     await this.stateMachine[transition]();
-                    this._logger.verbose(`${transition} for transfer ${this.data.transferId} has been completed`);
+                    log.isInfoEnabled && log.info(`Transition ${transition} for transfer has been completed`);
 
                     if (this.stateMachine.state === States.FX_QUOTE_RECEIVED) { // todo: think, if we need to add _autoAcceptConversion
-                        this._logger.isDebugEnabled && this._logger.debug(`Transfer ${this.data.transferId} waits for acceptConversion...`);
+                        log.isInfoEnabled && log.info('Transfer waits for async acceptConversion');
                         await this._save();
                         return this.getResponse();
                     }
@@ -1428,52 +1437,51 @@ class OutboundTransfersModel {
 
                 case States.FX_TRANSFER_SUCCEEDED:
                     await this.stateMachine.executeTransfer();
-                    this._logger.verbose(`Transfer ${this.data.transferId} has been completed`);
+                    log.isInfoEnabled && log.info('FxTransfer has been completed');
                     break;
 
                 case States.SUCCEEDED:
                     // all steps complete so return
-                    this._logger.isInfoEnabled && this._logger.info(`Transfer ${this.data.transferId} completed successfully`);
+                    log.isInfoEnabled && log.info('Transfer completed successfully');
                     await this._save();
                     return this.getResponse();
 
                 case States.ERRORED:
                     // stopped in errored state
                     await this._save();
-                    this._logger.isErrorEnabled && this._logger.error('State machine in errored state');
+                    log.isErrorEnabled && log.error('State machine in errored state');
                     return;
 
                 case States.ABORTED:
                     // stopped in aborted state
-                    this._logger.isWarnEnabled && this._logger.warn('State machine in aborted state');
+                    log.isWarnEnabled && log.warn('State machine in aborted state');
                     await this._save();
                     return this.getResponse();
 
                     // todo: no such state!
                 case 'getTransfer':
                     await this.stateMachine.getTransfer();
-                    this._logger.verbose(`Get transfer ${this.data.transferId} has been completed`);
+                    log.isInfoEnabled && log.info('getTransfer has been completed');
                     break;
 
                 default:
                     // The state is not handled here, throwing an error to avoid an infinite recursion of this function
                     await this._save();
-                    this._logger.isErrorEnabled && this._logger.error(`State machine in unhandled(${this.data.currentState}) state`);
+                    log.isErrorEnabled && log.error(`State machine in unhandled state: ${this.data.currentState}`);
                     return;
             }
 
             // now call ourselves recursively to deal with the next transition
-            this._logger.isDebugEnabled && this._logger.debug(`Transfer model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
+            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) {
-            this._logger.isErrorEnabled && this._logger.error(`error running outbound transfer model ${this.data.transferId}: ${err?.message}`);
+        } catch (err) {
+            log.isErrorEnabled && log.push({ err }).error(`error running outbound transfer model: ${err?.message}`);
 
             // as this function is recursive, we dont want to error the state machine multiple times
             if (this.data.currentState !== States.ERRORED) {
                 // err should not have a transferState property here!
                 if (err.transferState) {
-                    this._logger.isErrorEnabled && this._logger.error(`State machine is broken: ${safeStringify(err)}`);
+                    log.isWarnEnabled && log.warn(`State machine is broken: ${safeStringify(err)}`);
                 }
                 // transition to errored state
                 await this.stateMachine.error(err);

package/modules/api-svc/test/unit/config.test.js

@@ -39,6 +39,7 @@ jest.mock('dotenv', () => ({
 
 jest.mock('@mojaloop/sdk-standard-components', () => ({
     WSO2Auth: jest.fn(),
+    Logger: jest.requireActual('@mojaloop/sdk-standard-components').Logger,
 }));
 
 describe('config', () => {

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

@@ -33,6 +33,7 @@ process.env.CACHE_URL = 'redis://172.17.0.2:6379';
 process.env.MGMT_API_WS_URL = '0.0.0.0';
 process.env.SUPPORTED_CURRENCIES='USD';
 
+const uuid = require('@mojaloop/central-services-shared').Util.id({ type: 'ulid' });
 const mockError = require('./data/mockError');
 const mockBulkQuoteError = require('./data/mockBulkQuoteError');
 const mockBulkTransferError = require('./data/mockBulkTransferError');
@@ -46,7 +47,6 @@ const bulkQuoteRequest = require('./data/bulkQuoteRequest');
 const requestToPayPayload = require('./data/requestToPay');
 const requestToPayTransferRequest = require('./data/requestToPayTransferRequest');
 const mockLogger = require('../mockLogger');
-const uuid = require('@mojaloop/central-services-shared').Util.id({type: 'ulid'});
 
 jest.mock('~/lib/model');
 
@@ -170,13 +170,7 @@ describe('Outbound API handlers:', () => {
                 response: {},
                 state: {
                     conf: {},
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                 }
             };
 
@@ -204,13 +198,7 @@ describe('Outbound API handlers:', () => {
                     conf: {
                         outboundErrorStatusCodeExtensionKey: 'extErrorKey'  // <- tell the handler to use this extensionList item as source of statusCode
                     },
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                 }
             };
 
@@ -242,13 +230,7 @@ describe('Outbound API handlers:', () => {
                 response: {},
                 state: {
                     conf: {},
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                     path: {
                         params: {
                             transferId: '12345'
@@ -280,13 +262,7 @@ describe('Outbound API handlers:', () => {
                 response: {},
                 state: {
                     conf: {},
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                 }
             };
 
@@ -314,13 +290,7 @@ describe('Outbound API handlers:', () => {
                     conf: {
                         outboundErrorStatusCodeExtensionKey: 'extErrorKey'  // <- tell the handler to use this extensionList item as source of statusCode
                     },
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                 }
             };
 
@@ -350,13 +320,7 @@ describe('Outbound API handlers:', () => {
                 response: {},
                 state: {
                     conf: {},
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                 }
             };
 
@@ -384,13 +348,7 @@ describe('Outbound API handlers:', () => {
                     conf: {
                         outboundErrorStatusCodeExtensionKey: 'extErrorKey'  // <- tell the handler to use this extensionList item as source of statusCode
                     },
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                 }
             };
 
@@ -420,13 +378,7 @@ describe('Outbound API handlers:', () => {
                 response: {},
                 state: {
                     conf: {},
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                     eventLogger: { info: () => {}},
                     eventProducer: { sendDomainEvent: jest.fn() },
                 }
@@ -465,13 +417,7 @@ describe('Outbound API handlers:', () => {
                 response: {},
                 state: {
                     conf: {},
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                     eventLogger: { info: () => {}},
                     eventProducer: { sendDomainEvent: jest.fn() },
                     path: {
@@ -513,13 +459,7 @@ describe('Outbound API handlers:', () => {
                 response: {},
                 state: {
                     conf: {},
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                     eventLogger: { info: () => {}},
                     eventProducer: { sendDomainEvent: jest.fn() },
                     path: {
@@ -553,13 +493,7 @@ describe('Outbound API handlers:', () => {
                 response: {},
                 state: {
                     conf: {},
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {}
-                    },
+                    logger: mockLogger(),
                 }
             };
 
@@ -586,13 +520,7 @@ describe('Outbound API handlers:', () => {
                 response: {},
                 state: {
                     conf: {},
-                    logger: {
-                        log: () => {},
-                        debug: () => {},
-                        error: () => {},
-                        isDebugEnabled: () => {},
-                        isErrorEnabled: () => {},
-                    },
+                    logger: mockLogger(),
                 }
             };
 

package/modules/outbound-command-event-handler/package.json

@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@mojaloop/api-snippets": "17.8.0",
-    "@mojaloop/central-services-shared": "^18.18.1",
+    "@mojaloop/central-services-shared": "^18.18.2",
     "@mojaloop/logging-bc-client-lib": "^0.5.8",
     "@mojaloop/logging-bc-public-types-lib": "^0.5.4",
     "@mojaloop/sdk-scheme-adapter-private-shared-lib": "workspace:^",
@@ -55,17 +55,17 @@
     "yamljs": "^0.3.0"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.2.6",
+    "@eslint/compat": "^1.2.7",
     "@types/convict": "^6.1.6",
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.13.4",
+    "@types/node": "^22.13.5",
     "@types/node-cache": "^4.2.5",
     "@types/supertest": "^6.0.2",
     "@types/swagger-ui-express": "4.1.8",
     "@types/yamljs": "^0.2.34",
-    "@typescript-eslint/eslint-plugin": "^8.24.1",
-    "@typescript-eslint/parser": "^8.24.1",
+    "@typescript-eslint/eslint-plugin": "^8.25.0",
+    "@typescript-eslint/parser": "^8.25.0",
     "copyfiles": "^2.4.1",
     "eslint": "^9.15.0",
     "jest": "^29.7.0",
@@ -73,7 +73,7 @@
     "npm-check-updates": "^16.7.10",
     "replace": "^1.2.2",
     "standard-version": "^9.5.0",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.2.6",
     "ts-node": "^10.9.2",
     "typescript": "^5.7.3"
   },

package/modules/outbound-domain-event-handler/package.json

@@ -56,13 +56,13 @@
         "@types/convict": "^6.1.6",
         "@types/express": "^5.0.0",
         "@types/jest": "^29.5.14",
-        "@types/node": "^22.13.4",
+        "@types/node": "^22.13.5",
         "@types/node-cache": "^4.2.5",
         "@types/supertest": "^6.0.2",
         "@types/swagger-ui-express": "^4.1.8",
         "@types/yamljs": "^0.2.34",
-        "@typescript-eslint/eslint-plugin": "^8.24.1",
-        "@typescript-eslint/parser": "^8.24.1",
+        "@typescript-eslint/eslint-plugin": "^8.25.0",
+        "@typescript-eslint/parser": "^8.25.0",
         "copyfiles": "^2.4.1",
         "eslint": "^9.15.0",
         "jest": "^29.7.0",
@@ -70,7 +70,7 @@
         "npm-check-updates": "^16.7.10",
         "replace": "^1.2.2",
         "standard-version": "^9.5.0",
-        "ts-jest": "^29.2.5",
+        "ts-jest": "^29.2.6",
         "ts-node": "^10.9.2",
         "typescript": "^5.7.3"
     },

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

@@ -30,7 +30,7 @@
   },
   "dependencies": {
     "@mojaloop/api-snippets": "17.8.0",
-    "@mojaloop/central-services-shared": "^18.18.1",
+    "@mojaloop/central-services-shared": "^18.18.2",
     "@mojaloop/logging-bc-public-types-lib": "^0.5.4",
     "@mojaloop/platform-shared-lib-messaging-types-lib": "^0.7.1",
     "@mojaloop/platform-shared-lib-nodejs-kafka-client-lib": "0.5.18",
@@ -39,17 +39,17 @@
     "uuid": "^11.1.0"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.2.6",
-    "@types/node": "^22.13.4",
+    "@eslint/compat": "^1.2.7",
+    "@types/node": "^22.13.5",
     "@types/uuid": "^10.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.24.1",
-    "@typescript-eslint/parser": "^8.24.1",
+    "@typescript-eslint/eslint-plugin": "^8.25.0",
+    "@typescript-eslint/parser": "^8.25.0",
     "eslint": "^9.15.0",
     "jest": "^29.7.0",
     "npm-check-updates": "^16.7.10",
     "replace": "^1.2.2",
     "standard-version": "^9.5.0",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.2.6",
     "tslib": "^2.8.1",
     "typescript": "^5.7.3"
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/sdk-scheme-adapter",
-  "version": "24.1.0",
+  "version": "24.1.1",
   "description": "mojaloop sdk-scheme-adapter",
   "license": "Apache-2.0",
   "homepage": "https://github.com/mojaloop/sdk-scheme-adapter",
@@ -82,10 +82,10 @@
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.13.4",
+    "@types/node": "^22.13.5",
     "@types/node-cache": "^4.2.5",
-    "@typescript-eslint/eslint-plugin": "^8.24.1",
-    "@typescript-eslint/parser": "^8.24.1",
+    "@typescript-eslint/eslint-plugin": "^8.25.0",
+    "@typescript-eslint/parser": "^8.25.0",
     "audit-ci": "^7.1.0",
     "eslint": "^9.15.0",
     "eslint-config-airbnb-typescript": "^18.0.0",
@@ -96,7 +96,7 @@
     "npm-check-updates": "^16.7.10",
     "replace": "^1.2.2",
     "standard-version": "^9.5.0",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.2.6",
     "ts-node": "^10.9.2",
     "typescript": "^5.7.3",
     "yarn-audit-fix": "^10.1.1"