account-lookup-service 15.6.0-iso.13 → 15.6.0-iso.14

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "account-lookup-service",
   "description": "Account Lookup Service is used to validate Party and Participant lookups.",
-  "version": "15.6.0-iso.13",
+  "version": "15.6.0-iso.14",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [

package/src/constants.js

@@ -1,5 +1,6 @@
 const ERROR_MESSAGES = Object.freeze({
-  partySourceFspNotFound: 'Requester FSP not found',
+  sourceFspNotFound: 'Requester FSP not found',
+  partySourceFspNotFound: 'Requester FSP not found', // todo: use sourceFspNotFound
   partyDestinationFspNotFound: 'Destination FSP not found',
   partyProxyNotFound: 'Proxy not found',
   proxyConnectionError: 'Proxy connection error',

package/src/domain/participants/participants.js

@@ -28,7 +28,6 @@
 
 const Enums = require('@mojaloop/central-services-shared').Enum
 const { decodePayload } = require('@mojaloop/central-services-shared').Util.StreamingProtocol
-const Logger = require('@mojaloop/central-services-logger')
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const EventSdk = require('@mojaloop/event-sdk')
 const Metrics = require('@mojaloop/central-services-metrics')
@@ -36,6 +35,10 @@ const Metrics = require('@mojaloop/central-services-metrics')
 const oracle = require('../../models/oracle/facade')
 const participant = require('../../models/participantEndpoint/facade')
 const Config = require('../../lib/config')
+const { logger } = require('../../lib')
+const { ERROR_MESSAGES } = require('../../constants')
+
+const { FSPIOPErrorCodes } = ErrorHandler.Enums
 
 /**
  * @function getParticipantsByTypeAndID
@@ -55,57 +58,85 @@ const getParticipantsByTypeAndID = async (headers, params, method, query, span,
     'Get participants by ID',
     ['success']
   ).startTimer()
+  const log = logger.child('getParticipantsByTypeAndID')
   const type = params.Type
-  const partySubIdOrType = params.SubId || undefined
-  const requesterName = headers[Enums.Http.Headers.FSPIOP.SOURCE]
-  const callbackEndpointType = partySubIdOrType ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT
-  const errorCallbackEndpointType = params.SubId ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT_ERROR : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT_ERROR
+  const partySubIdOrType = params.SubId
+  const source = headers[Enums.Http.Headers.FSPIOP.SOURCE]
+  const callbackEndpointType = partySubIdOrType
+    ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT
+    : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT
+  const errorCallbackEndpointType = params.SubId
+    ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT_ERROR
+    : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT_ERROR
+
   let fspiopError
+
   try {
-    Logger.isInfoEnabled && Logger.info('getParticipantsByTypeAndID::begin')
-    const requesterParticipantModel = await participant.validateParticipant(headers[Enums.Http.Headers.FSPIOP.SOURCE], childSpan)
-    if (requesterParticipantModel) {
-      const response = await oracle.oracleRequest(headers, method, params, query, undefined, cache)
-      if (response && response.data && Array.isArray(response.data.partyList) && response.data.partyList.length > 0) {
-        let options = {
-          partyIdType: type,
-          partyIdentifier: params.ID
-        }
-        options = partySubIdOrType ? { ...options, partySubIdOrType } : options
-        const payload = {
-          fspId: response.data.partyList[0].fspId
-        }
-        const clonedHeaders = { ...headers }
-        if (!clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] || clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] === '') {
-          clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] = clonedHeaders[Enums.Http.Headers.FSPIOP.SOURCE]
-        }
-        clonedHeaders[Enums.Http.Headers.FSPIOP.SOURCE] = Config.HUB_NAME
-        await participant.sendRequest(clonedHeaders, requesterName, callbackEndpointType, Enums.Http.RestMethods.PUT, payload, options, childSpan)
-      } else {
-        await participant.sendErrorToParticipant(requesterName, errorCallbackEndpointType,
-          ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND).toApiErrorObject(Config.ERROR_HANDLING), headers, params, childSpan)
+    log.info('processing started...', { source, params })
+    const requesterParticipantModel = await participant.validateParticipant(source)
+
+    if (!requesterParticipantModel) {
+      const errMessage = ERROR_MESSAGES.sourceFspNotFound
+      logger.warn(errMessage, { requesterName: source })
+      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+    }
+
+    const response = await oracle.oracleRequest(headers, method, params, query, undefined, cache)
+    if (response?.data && Array.isArray(response.data.partyList) && response.data.partyList.length > 0) {
+      const options = {
+        partyIdType: type,
+        partyIdentifier: params.ID,
+        ...(partySubIdOrType && { partySubIdOrType })
+      }
+      const payload = {
+        fspId: response.data.partyList[0].fspId
+      }
+      const clonedHeaders = { ...headers }
+      if (!clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] || clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] === '') {
+        clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] = clonedHeaders[Enums.Http.Headers.FSPIOP.SOURCE]
       }
-      Logger.isInfoEnabled && Logger.info('getParticipantsByTypeAndID::end')
+      clonedHeaders[Enums.Http.Headers.FSPIOP.SOURCE] = Config.HUB_NAME
+      await participant.sendRequest(
+        clonedHeaders,
+        source,
+        callbackEndpointType,
+        Enums.Http.RestMethods.PUT,
+        payload,
+        options,
+        childSpan
+      )
     } else {
-      Logger.isErrorEnabled && Logger.error('Requester FSP not found')
-      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, 'Requester FSP not found')
+      await participant.sendErrorToParticipant(
+        source,
+        errorCallbackEndpointType,
+        ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND).toApiErrorObject(Config.ERROR_HANDLING),
+        headers,
+        params,
+        childSpan
+      )
     }
+    log.info('processing finished', { source, params })
+
     if (childSpan && !childSpan.isFinished) {
       await childSpan.finish()
     }
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(err)
+    log.warn('error in getParticipantsByTypeAndID', err)
     fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err, ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR)
     try {
-      const errorCallbackEndpointType = params.SubId ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT_ERROR : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT_ERROR
       await participant.sendErrorToParticipant(
-        headers[Enums.Http.Headers.FSPIOP.SOURCE], errorCallbackEndpointType,
-        fspiopError.toApiErrorObject(Config.ERROR_HANDLING), headers, params, childSpan)
+        headers[Enums.Http.Headers.FSPIOP.SOURCE],
+        errorCallbackEndpointType,
+        fspiopError.toApiErrorObject(Config.ERROR_HANDLING),
+        headers,
+        params,
+        childSpan
+      )
     } catch (exc) {
       fspiopError = ErrorHandler.Factory.reformatFSPIOPError(exc)
       // We can't do anything else here- we _must_ handle all errors _within_ this function because
       // we've already sent a sync response- we cannot throw.
-      Logger.isErrorEnabled && Logger.error(exc)
+      log.error('error in final participant.sendErrorToParticipant', exc)
     }
   } finally {
     if (childSpan && !childSpan.isFinished && fspiopError) {
@@ -138,7 +169,7 @@ const putParticipantsByTypeAndID = async (headers, params, method, payload, cach
     ['success']
   ).startTimer()
   try {
-    Logger.isInfoEnabled && Logger.info('putParticipantsByTypeAndID::begin')
+    logger.info('putParticipantsByTypeAndID::begin')
     const type = params.Type
     const partySubIdOrType = params.SubId || undefined
     const callbackEndpointType = partySubIdOrType ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT
@@ -177,17 +208,17 @@ const putParticipantsByTypeAndID = async (headers, params, method, payload, cach
             ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR).toApiErrorObject(Config.ERROR_HANDLING), headers, params)
         }
       } else {
-        Logger.isErrorEnabled && Logger.error('Requester FSP not found')
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, 'Requester FSP not found')
+        logger.warn(ERROR_MESSAGES.sourceFspNotFound)
+        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.sourceFspNotFound)
       }
     } else {
       await participant.sendErrorToParticipant(headers[Enums.Http.Headers.FSPIOP.SOURCE], errorCallbackEndpointType,
         ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR).toApiErrorObject(Config.ERROR_HANDLING), headers, params)
     }
-    Logger.isInfoEnabled && Logger.info('putParticipantsByTypeAndID::end')
+    logger.info('putParticipantsByTypeAndID::end')
     histTimerEnd({ success: true })
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(err)
+    logger.error('error in putParticipantsByTypeAndID:', err)
     try {
       const errorCallbackEndpointType = params.SubId ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT_ERROR : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT_ERROR
       await participant.sendErrorToParticipant(headers[Enums.Http.Headers.FSPIOP.SOURCE], errorCallbackEndpointType,
@@ -195,7 +226,7 @@ const putParticipantsByTypeAndID = async (headers, params, method, payload, cach
     } catch (exc) {
       // We can't do anything else here- we _must_ handle all errors _within_ this function because
       // we've already sent a sync response- we cannot throw.
-      Logger.isErrorEnabled && Logger.error(exc)
+      logger.error('error in participant.sendErrorToParticipant:', exc)
     }
     histTimerEnd({ success: false })
   }
@@ -247,9 +278,11 @@ const putParticipantsErrorByTypeAndID = async (headers, params, payload, dataUri
     }
     histTimerEnd({ success: true })
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(err)
+    logger.error('error in putParticipantsErrorByTypeAndID:', err)
     try {
-      const callbackEndpointType = params.SubId ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT_ERROR : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT_ERROR
+      const callbackEndpointType = params.SubId
+        ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT_ERROR
+        : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT_ERROR
       await participant.sendErrorToParticipant(
         headers[Enums.Http.Headers.FSPIOP.SOURCE],
         callbackEndpointType,
@@ -260,7 +293,7 @@ const putParticipantsErrorByTypeAndID = async (headers, params, payload, dataUri
     } catch (exc) {
       // We can't do anything else here- we _must_ handle all errors _within_ this function because
       // we've already sent a sync response- we cannot throw.
-      Logger.isErrorEnabled && Logger.error(exc)
+      logger.error('error in participant.sendErrorToParticipant:', exc)
     }
     histTimerEnd({ success: false })
   }
@@ -286,7 +319,7 @@ const postParticipants = async (headers, method, params, payload, span, cache) =
   const childSpan = span ? span.getChild('postParticipants') : undefined
   let fspiopError
   try {
-    Logger.isInfoEnabled && Logger.info('postParticipants::begin')
+    logger.info('postParticipants::begin')
     const type = params.Type
     const partySubIdOrType = params.SubId
     const callbackEndpointType = partySubIdOrType
@@ -334,8 +367,9 @@ const postParticipants = async (headers, method, params, payload, span, cache) =
             fspiopError.toApiErrorObject(Config.ERROR_HANDLING), headers, params, childSpan)
         }
       } else {
-        fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, 'Requester FSP not found')
-        Logger.isErrorEnabled && Logger.error('Requester FSP not found')
+        const errMessage = ERROR_MESSAGES.sourceFspNotFound
+        logger.error(errMessage)
+        fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
         throw fspiopError
       }
     } else {
@@ -343,10 +377,10 @@ const postParticipants = async (headers, method, params, payload, span, cache) =
       await participant.sendErrorToParticipant(headers[Enums.Http.Headers.FSPIOP.SOURCE], errorCallbackEndpointType,
         fspiopError.toApiErrorObject(Config.ERROR_HANDLING), headers, params, childSpan)
     }
-    Logger.isInfoEnabled && Logger.info('postParticipants::end')
+    logger.info('postParticipants::end')
     histTimerEnd({ success: true })
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(`error in postParticipants: ${err?.message}`)
+    logger.error('error in postParticipants:', err)
     fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err, ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR)
     try {
       const errorCallbackEndpointType = params.SubId
@@ -357,7 +391,7 @@ const postParticipants = async (headers, method, params, payload, span, cache) =
     } catch (exc) {
       // We can't do anything else here- we _must_ handle all errors _within_ this function because
       // we've already sent a sync response- we cannot throw.
-      Logger.isErrorEnabled && Logger.error(`failed to handle exception in postParticipants due to error: ${exc?.stack}`)
+      logger.error('failed to handle exception in postParticipants:', exc)
     }
     histTimerEnd({ success: false })
   } finally {
@@ -385,92 +419,90 @@ const postParticipantsBatch = async (headers, method, requestPayload, span) => {
     'Post participants batch',
     ['success']
   ).startTimer()
+  const requestId = requestPayload.requestId
+  const log = logger.child({ context: 'postParticipantsBatch', requestId })
   const childSpan = span ? span.getChild('postParticipantsBatch') : undefined
   let fspiopError
+
   try {
-    Logger.isInfoEnabled && Logger.info('postParticipantsBatch::begin')
+    log.info('postParticipantsBatch::begin', { headers, requestPayload })
     const typeMap = new Map()
     const overallReturnList = []
-    const requestId = requestPayload.requestId
+    const pushPartyError = (party, errCode) => {
+      log.debug('party error details:', { party, errCode })
+      overallReturnList.push({
+        partyId: party,
+        ...ErrorHandler.Factory.createFSPIOPError(errCode, undefined, undefined, undefined, [{
+          key: party.partyIdType,
+          value: party.partyIdentifier
+        }]).toApiErrorObject(Config.ERROR_HANDLING)
+      })
+    }
+
     const requesterParticipantModel = await participant.validateParticipant(headers[Enums.Http.Headers.FSPIOP.SOURCE], childSpan)
-    if (requesterParticipantModel) {
-      for (const party of requestPayload.partyList) {
-        if (Object.values(Enums.Accounts.PartyAccountTypes).includes(party.partyIdType)) {
-          party.currency = requestPayload.currency
-          if (party.fspId === headers[Enums.Http.Headers.FSPIOP.SOURCE]) {
-            if (typeMap.get(party.partyIdType)) {
-              const partyList = typeMap.get(party.partyIdType)
-              partyList.push(party)
-              typeMap.set(party.partyIdType, partyList)
-            } else {
-              typeMap.set(party.partyIdType, [party])
-            }
-          } else {
-            overallReturnList.push(ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND, undefined, undefined, undefined, [{
-              key: party.partyIdType,
-              value: party.partyIdentifier
-            }]).toApiErrorObject(Config.ERROR_HANDLING))
-          }
-        } else {
-          overallReturnList.push(ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, undefined, undefined, undefined, [{
-            key: party.partyIdType,
-            value: party.partyIdentifier
-          }]).toApiErrorObject(Config.ERROR_HANDLING))
-        }
-      }
+    if (!requesterParticipantModel) {
+      const errMessage = ERROR_MESSAGES.sourceFspNotFound
+      log.error(errMessage)
+      fspiopError = ErrorHandler.Factory.createFSPIOPError(FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+      throw fspiopError
+    }
 
-      for (const [key, value] of typeMap) {
-        const payload = {
-          requestId,
-          partyList: value
-        }
-        Logger.isInfoEnabled && Logger.info(`postParticipantsBatch::oracleBatchRequest::type=${key}`)
-        const response = await oracle.oracleBatchRequest(headers, method, requestPayload, key, payload)
-        if (response && (response.data !== null || response.data !== undefined)) {
-          if (Array.isArray(response.data.partyList) && response.data.partyList.length > 0) {
-            for (const party of response.data.partyList) {
-              party.partyId.currency = undefined
-              overallReturnList.push(party)
-            }
+    for (const party of requestPayload.partyList) {
+      if (Object.values(Enums.Accounts.PartyAccountTypes).includes(party.partyIdType)) {
+        party.currency = requestPayload.currency
+        if (party.fspId === headers[Enums.Http.Headers.FSPIOP.SOURCE]) {
+          if (typeMap.get(party.partyIdType)) {
+            const partyList = typeMap.get(party.partyIdType)
+            partyList.push(party)
+            typeMap.set(party.partyIdType, partyList)
           } else {
-            for (const party of value) {
-              overallReturnList.push(ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, undefined, undefined, undefined, [{
-                key: party.partyIdType,
-                value: party.partyIdentifier
-              }]).toApiErrorObject(Config.ERROR_HANDLING))
-            }
+            typeMap.set(party.partyIdType, [party])
           }
         } else {
-          for (const party of value) {
-            overallReturnList.push(ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, undefined, undefined, undefined, [{
-              key: party.partyIdType,
-              value: party.partyIdentifier
-            }]).toApiErrorObject(Config.ERROR_HANDLING))
-          }
+          pushPartyError(party, FSPIOPErrorCodes.PARTY_NOT_FOUND)
         }
+      } else {
+        pushPartyError(party, FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR)
       }
+    }
+
+    for (const [key, value] of typeMap) {
       const payload = {
-        partyList: overallReturnList,
-        currency: requestPayload.currency
+        requestId,
+        partyList: value
       }
-      const clonedHeaders = { ...headers }
-      if (!clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] || clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] === '') {
-        clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] = payload.partyList[0].partyId.fspId
-        clonedHeaders[Enums.Http.Headers.FSPIOP.SOURCE] = Config.HUB_NAME
-      }
-      await participant.sendRequest(clonedHeaders, clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION], Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_BATCH_PUT, Enums.Http.RestMethods.PUT, payload, { requestId }, childSpan)
-      if (childSpan && !childSpan.isFinished) {
-        await childSpan.finish()
+      log.info(`postParticipantsBatch::oracleBatchRequest::type=${key}`, { payload })
+      const response = await oracle.oracleBatchRequest(headers, method, requestPayload, key, payload)
+      if (Array.isArray(response?.data?.partyList) && response.data.partyList.length > 0) {
+        for (const party of response.data.partyList) {
+          party.partyId.currency = undefined
+          overallReturnList.push(party)
+        }
+      } else {
+        for (const party of value) {
+          pushPartyError(party, FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR)
+        }
       }
-      Logger.isInfoEnabled && Logger.info('postParticipantsBatch::end')
-    } else {
-      Logger.isErrorEnabled && Logger.error('Requester FSP not found')
-      fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, 'Requester FSP not found')
-      throw fspiopError
     }
+
+    const payload = {
+      partyList: overallReturnList,
+      currency: requestPayload.currency
+    }
+    const clonedHeaders = { ...headers }
+    if (!clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] || clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] === '') {
+      clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] = headers[Enums.Http.Headers.FSPIOP.SOURCE]
+      clonedHeaders[Enums.Http.Headers.FSPIOP.SOURCE] = Config.HUB_NAME
+    }
+    await participant.sendRequest(clonedHeaders, clonedHeaders[Enums.Http.Headers.FSPIOP.DESTINATION], Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_BATCH_PUT, Enums.Http.RestMethods.PUT, payload, { requestId }, childSpan)
+    if (childSpan && !childSpan.isFinished) {
+      await childSpan.finish()
+    }
+    log.info('postParticipantsBatch::end')
+
     histTimerEnd({ success: true })
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(err)
+    log.error('error in postParticipantsBatch', err)
     fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
     try {
       await participant.sendErrorToParticipant(headers[Enums.Http.Headers.FSPIOP.SOURCE], Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_BATCH_PUT_ERROR,
@@ -478,7 +510,7 @@ const postParticipantsBatch = async (headers, method, requestPayload, span) => {
     } catch (exc) {
       // We can't do anything else here- we _must_ handle all errors _within_ this function because
       // we've already sent a sync response- we cannot throw.
-      Logger.isErrorEnabled && Logger.error(exc)
+      log.error('error in participant.sendErrorToParticipant', exc)
     }
     histTimerEnd({ success: false })
   } finally {
@@ -507,8 +539,9 @@ const deleteParticipants = async (headers, params, method, query, cache) => {
     'Delete participants',
     ['success']
   ).startTimer()
+  const log = logger.child('deleteParticipants')
   try {
-    Logger.isInfoEnabled && Logger.info('deleteParticipants::begin')
+    log.debug('deleteParticipants::begin', { headers, params })
     const type = params.Type
     const partySubIdOrType = params.SubId || undefined
     const callbackEndpointType = partySubIdOrType ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT
@@ -535,17 +568,18 @@ const deleteParticipants = async (headers, params, method, query, cache) => {
             ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DELETE_PARTY_INFO_ERROR).toApiErrorObject(Config.ERROR_HANDLING), headers, params)
         }
       } else {
-        Logger.isErrorEnabled && Logger.error('Requester FSP not found')
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, 'Requester FSP not found')
+        const errMessage = ERROR_MESSAGES.sourceFspNotFound
+        log.error(errMessage)
+        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
       }
     } else {
       await participant.sendErrorToParticipant(headers[Enums.Http.Headers.FSPIOP.SOURCE], errorCallbackEndpointType,
         ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DELETE_PARTY_INFO_ERROR).toApiErrorObject(Config.ERROR_HANDLING), headers, params)
     }
-    Logger.isInfoEnabled && Logger.info('deleteParticipants::end')
+    log.info('deleteParticipants::end')
     histTimerEnd({ success: true })
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(err)
+    log.error('error in deleteParticipants', err)
     try {
       const errorCallbackEndpointType = params.SubId ? Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT_ERROR : Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT_ERROR
       await participant.sendErrorToParticipant(headers[Enums.Http.Headers.FSPIOP.SOURCE], errorCallbackEndpointType,
@@ -553,7 +587,7 @@ const deleteParticipants = async (headers, params, method, query, cache) => {
     } catch (exc) {
       // We can't do anything else here- we _must_ handle all errors _within_ this function because
       // we've already sent a sync response- we cannot throw.
-      Logger.isErrorEnabled && Logger.error(exc)
+      log.error('error in participant.sendErrorToParticipant', exc)
     }
     histTimerEnd({ success: false })
   }

package/test/unit/api/participants/participants.test.js

@@ -35,16 +35,12 @@ const Helper = require('../../../util/helper')
 const participants = require('../../../../src/domain/participants')
 const initServer = require('../../../../src/server').initializeApi
 const getPort = require('get-port')
-const Logger = require('@mojaloop/central-services-logger')
 const Config = require('../../../../src/lib/config')
 
-Logger.isDebugEnabled = jest.fn(() => true)
-Logger.isErrorEnabled = jest.fn(() => true)
-Logger.isInfoEnabled = jest.fn(() => true)
-let server
-let sandbox
-
 describe('/participants', () => {
+  let server
+  let sandbox
+
   beforeAll(async () => {
     sandbox = Sinon.createSandbox()
     sandbox.stub(Db, 'connect').returns(Promise.resolve({}))
@@ -56,6 +52,7 @@ describe('/participants', () => {
     await server.stop()
     sandbox.restore()
   })
+
   const mock = {
     requestId: '3ede3c17-36aa-42f4-b6db-b0df2e42f31e',
     partyList: [{
@@ -79,6 +76,7 @@ describe('/participants', () => {
     ],
     currency: 'EUR'
   }
+
   it('postParticipantsBatch success', async () => {
     // Arrange
     const options = {

package/test/unit/domain/participants/participants.test.js

@@ -38,12 +38,13 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const participantsDomain = require('../../../../src/domain/participants/participants')
 const participant = require('../../../../src/models/participantEndpoint/facade')
 const oracle = require('../../../../src/models/oracle/facade')
-const Helper = require('../../../util/helper')
 const Config = require('../../../../src/lib/config')
+const { logger } = require('../../../../src/lib')
+const { ERROR_MESSAGES } = require('../../../../src/constants')
+const Helper = require('../../../util/helper')
+const fixtures = require('../../../fixtures')
 
-Logger.isDebugEnabled = jest.fn(() => true)
-Logger.isErrorEnabled = jest.fn(() => true)
-Logger.isInfoEnabled = jest.fn(() => true)
+const { Headers } = Enums.Http
 
 describe('participant Tests', () => {
   describe('getParticipantsByTypeAndID', () => {
@@ -185,7 +186,7 @@ describe('participant Tests', () => {
       expect.hasAssertions()
       // Arrange
       participant.validateParticipant = sandbox.stub().resolves(null)
-      const logErrorStub = sandbox.stub(Logger, 'error')
+      const logStub = sandbox.stub(logger.constructor.prototype, 'warn')
 
       participant.sendRequest = sandbox.stub()
       const args = [
@@ -199,8 +200,8 @@ describe('participant Tests', () => {
       await participantsDomain.getParticipantsByTypeAndID(...args)
 
       // Assert
-      const firstCallArgs = logErrorStub.getCall(0).args
-      expect(firstCallArgs[0]).toBe('Requester FSP not found')
+      const firstCallArgs = logStub.getCall(0).args
+      expect(firstCallArgs[0]).toBe(ERROR_MESSAGES.sourceFspNotFound)
     })
 
     it('fails when `oracleRequest` response is empty', async () => {
@@ -485,9 +486,8 @@ describe('participant Tests', () => {
     it('handles the case where `validateParticipant` returns null', async () => {
       expect.hasAssertions()
       // Arrange
+      const logStub = sandbox.stub(logger.constructor.prototype, 'error')
       participant.validateParticipant = sandbox.stub().resolves(null)
-      sandbox.stub(Logger)
-      Logger.error = sandbox.stub()
       participant.sendErrorToParticipant = sandbox.stub()
       const headers = {
         accept: 'application/vnd.interoperability.participants+json;version=1',
@@ -510,8 +510,7 @@ describe('participant Tests', () => {
       await participantsDomain.putParticipantsByTypeAndID(headers, params, method, payload)
 
       // Assert
-      const loggerFirstCallArgs = Logger.error.getCall(0).args
-      expect(loggerFirstCallArgs[0]).toBe('Requester FSP not found')
+      expect(logStub.getCall(0).args[1].message).toBe(ERROR_MESSAGES.sourceFspNotFound)
     })
 
     it('handles case where type is not in `PartyAccountTypes`', async () => {
@@ -739,9 +738,6 @@ describe('participant Tests', () => {
     it('handles PUT /error when SubId supplied but validateParticipant throws error', async () => {
       expect.hasAssertions()
       // Arrange
-      sandbox.stub(Logger)
-      Logger.info = sandbox.stub()
-      Logger.error = sandbox.stub()
       participant.validateParticipant = sandbox.stub().throws(new Error('Validation failed'))
       oracle.oracleRequest = sandbox.stub().resolves(null)
       participant.sendErrorToParticipant = sandbox.stub()
@@ -771,15 +767,11 @@ describe('participant Tests', () => {
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
       const firstCallArgs = participant.sendErrorToParticipant.getCall(0).args
       expect(firstCallArgs[1]).toBe(expectedCallbackEndpointType)
-      expect(Logger.error.callCount).toBe(1)
     })
 
     it('handles PUT /error when `sendErrorToParticipant` throws error', async () => {
       expect.hasAssertions()
       // Arrange
-      sandbox.stub(Logger)
-      Logger.info = sandbox.stub()
-      Logger.error = sandbox.stub()
       participant.validateParticipant = sandbox.stub().resolves({})
       participant.sendErrorToParticipant = sandbox.stub().throws(new Error('sendErrorToParticipant failed'))
       const expectedCallbackEndpointType = Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_PUT_ERROR
@@ -809,15 +801,11 @@ describe('participant Tests', () => {
       const secondCallArgs = participant.sendErrorToParticipant.getCall(1).args
       expect(firstCallArgs[1]).toBe(expectedCallbackEndpointType)
       expect(secondCallArgs[0]).toBe(Config.HUB_NAME)
-      expect(Logger.error.callCount).toBe(2)
     })
 
     it('handles PUT /error when SubId is supplied and `sendErrorToParticipant` throws error', async () => {
       expect.hasAssertions()
       // Arrange
-      sandbox.stub(Logger)
-      Logger.info = sandbox.stub()
-      Logger.error = sandbox.stub()
       participant.validateParticipant = sandbox.stub().resolves({})
       participant.sendErrorToParticipant = sandbox.stub().throws(new Error('sendErrorToParticipant failed'))
       const expectedCallbackEndpointType = Enums.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTICIPANT_SUB_ID_PUT_ERROR
@@ -848,7 +836,6 @@ describe('participant Tests', () => {
       const secondCallArgs = participant.sendErrorToParticipant.getCall(1).args
       expect(firstCallArgs[1]).toBe(expectedCallbackEndpointType)
       expect(secondCallArgs[0]).toBe(Config.HUB_NAME)
-      expect(Logger.error.callCount).toBe(2)
     })
   })
 
@@ -1048,9 +1035,8 @@ describe('participant Tests', () => {
     it('handles the case where `validateParticipant` returns null', async () => {
       expect.hasAssertions()
       // Arrange
+      const logStub = sandbox.stub(logger.constructor.prototype, 'error')
       participant.validateParticipant = sandbox.stub().resolves(null)
-      sandbox.stub(Logger)
-      Logger.error = sandbox.stub()
       participant.sendErrorToParticipant = sandbox.stub()
       const headers = {
         accept: 'application/vnd.interoperability.participants+json;version=1',
@@ -1072,8 +1058,7 @@ describe('participant Tests', () => {
       await participantsDomain.postParticipants(headers, 'get', params, payload)
 
       // Assert
-      const loggerFirstCallArgs = Logger.error.getCall(0).args
-      expect(loggerFirstCallArgs[0]).toBe('Requester FSP not found')
+      expect(logStub.getCall(0).args[0]).toBe(ERROR_MESSAGES.sourceFspNotFound)
     })
 
     it('handles case where type is not in `PartyAccountTypes`', async () => {
@@ -1202,7 +1187,7 @@ describe('participant Tests', () => {
 
       const headers = {
         accept: 'application/vnd.interoperability.participants+json;version=1',
-        'fspiop-destination': Config.HUB_NAME,
+        // 'fspiop-destination': Config.HUB_NAME,
         'content-type': 'application/vnd.interoperability.participants+json;version=1.1',
         date: '2019-05-24 08:52:19',
         'fspiop-source': 'fsp1'
@@ -1318,15 +1303,23 @@ describe('participant Tests', () => {
       const expected = {
         currency: 'USD',
         partyList: [
-          ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND, undefined, undefined, undefined, [{
-            key: Enums.Accounts.PartyAccountTypes.MSISDN,
-            value: undefined
-          }]).toApiErrorObject(Config.ERROR_HANDLING),
-          ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, undefined, undefined, undefined, [{
-            key: 'NOT_A_VALID_PARTY_ID',
-            value: undefined
-          }]).toApiErrorObject(Config.ERROR_HANDLING),
-          { partyId: { currency: undefined } }
+          {
+            ...ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND, undefined, undefined, undefined, [{
+              key: Enums.Accounts.PartyAccountTypes.MSISDN,
+              value: undefined
+            }]).toApiErrorObject(Config.ERROR_HANDLING),
+            partyId: payload.partyList[1]
+          },
+          {
+            ...ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, undefined, undefined, undefined, [{
+              key: 'NOT_A_VALID_PARTY_ID',
+              value: undefined
+            }]).toApiErrorObject(Config.ERROR_HANDLING),
+            partyId: payload.partyList[2]
+          },
+          {
+            partyId: { currency: undefined }
+          }
         ]
       }
 
@@ -1342,10 +1335,10 @@ describe('participant Tests', () => {
     it('handles error when `validateParticipant` fails and `sendErrorToParticipant` throws', async () => {
       expect.hasAssertions()
       // Arrange
-      sandbox.stub(Logger)
-      Logger.error = sandbox.stub()
+      const logStub = sandbox.stub(logger.constructor.prototype, 'error')
       participant.validateParticipant = sandbox.stub().resolves(null)
-      participant.sendErrorToParticipant = sandbox.stub().throws(new Error('unknown error'))
+      const cbError = new Error('unknown error')
+      participant.sendErrorToParticipant = sandbox.stub().throws(cbError)
 
       const headers = {
         accept: 'application/vnd.interoperability.participants+json;version=1',
@@ -1368,10 +1361,8 @@ describe('participant Tests', () => {
       await participantsDomain.postParticipantsBatch(headers, 'get', payload, Helper.mockSpan())
 
       // Assert
-      const firstCallArgs = Logger.error.getCall(0).args
-      const thirdCallArgs = Logger.error.getCall(2).args
-      expect(firstCallArgs[0]).toBe('Requester FSP not found')
-      expect(thirdCallArgs[0].message).toBe('unknown error')
+      expect(logStub.getCall(0).firstArg).toBe(ERROR_MESSAGES.sourceFspNotFound)
+      expect(logStub.getCall(2).lastArg).toEqual(cbError)
     })
 
     it('handles error when `oracleBatchRequest` returns no result', async () => {
@@ -1447,6 +1438,44 @@ describe('participant Tests', () => {
       expect(firstCallArgs[4].partyList[1].errorInformation).toBeDefined()
       expect(firstCallArgs[4].partyList[2].errorInformation).toBeDefined()
     })
+
+    it('should not call oracle if source-header and fspId in payload are different, and no destination [CSI-938]', async () => {
+      const headers = fixtures.participantsCallHeadersDto({ destination: '' })
+      const payload = {
+        requestId: '0e21b07e-3117-46ca-ae22-6ee370895697',
+        currency: 'MWK',
+        partyList: [
+          {
+            fspId: 'test-mwk-dfsp',
+            partyIdType: 'MSISDN',
+            partyIdentifier: '16665551002'
+          }
+        ]
+      }
+      expect(headers.source).not.toBe(payload.partyList[0].fspId)
+      expect(headers.destination).toBeUndefined()
+
+      participant.validateParticipant = sandbox.stub().resolves({})
+      participant.sendRequest = sandbox.stub()
+      participant.sendErrorToParticipant = sandbox.stub().resolves({})
+      oracle.oracleBatchRequest = sandbox.stub().resolves({})
+
+      await participantsDomain.postParticipantsBatch(headers, 'put', payload, Helper.mockSpan())
+
+      expect(oracle.oracleBatchRequest.callCount).toBe(0)
+      expect(participant.sendErrorToParticipant.callCount).toBe(0)
+      expect(participant.sendRequest.callCount).toBe(1)
+
+      const { args } = participant.sendRequest.getCall(0)
+      expect(args[0][Headers.FSPIOP.DESTINATION]).toBe(headers[Headers.FSPIOP.SOURCE])
+      expect(args[0][Headers.FSPIOP.SOURCE]).toBe(Config.HUB_NAME)
+      expect(args[1]).toBe(headers[Headers.FSPIOP.SOURCE])
+
+      const { partyList } = args[4]
+      expect(partyList.length).toBe(1)
+      expect(partyList[0].errorInformation).toBeDefined()
+      expect(partyList[0].partyId).toBe(payload.partyList[0])
+    })
   })
 
   describe('deleteParticipants', () => {
@@ -1602,9 +1631,8 @@ describe('participant Tests', () => {
     it('handles the case where `validateParticipant` returns null', async () => {
       expect.hasAssertions()
       // Arrange
+      const logStub = sandbox.stub(logger.constructor.prototype, 'error')
       participant.validateParticipant = sandbox.stub().resolves(null)
-      sandbox.stub(Logger)
-      Logger.error = sandbox.stub()
       participant.sendErrorToParticipant = sandbox.stub()
       const headers = {
         accept: 'application/vnd.interoperability.participants+json;version=1',
@@ -1625,8 +1653,8 @@ describe('participant Tests', () => {
       await participantsDomain.deleteParticipants(headers, params, method, query)
 
       // Assert
-      const loggerFirstCallArgs = Logger.error.getCall(0).args
-      expect(loggerFirstCallArgs[0]).toBe('Requester FSP not found')
+      expect(logStub.getCall(0).firstArg).toBe(ERROR_MESSAGES.sourceFspNotFound)
+      // expect(logStub.getCall()]).toBe(ERROR_MESSAGES.sourceFspNotFound)
     })
 
     it('handles case where type is not in `PartyAccountTypes`', async () => {