account-lookup-service 17.8.0-snapshot.11 → 17.8.0-snapshot.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "account-lookup-service",
   "description": "Account Lookup Service is used to validate Party and Participant lookups.",
-  "version": "17.8.0-snapshot.11",
+  "version": "17.8.0-snapshot.13",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
@@ -92,14 +92,14 @@
     "@hapi/vision": "7.0.3",
     "@mojaloop/central-services-error-handling": "13.0.7",
     "@mojaloop/central-services-health": "15.0.4",
-    "@mojaloop/central-services-logger": "11.8.0",
+    "@mojaloop/central-services-logger": "11.8.1",
     "@mojaloop/central-services-metrics": "12.5.0",
-    "@mojaloop/central-services-shared": "18.23.1",
+    "@mojaloop/central-services-shared": "18.23.2",
     "@mojaloop/central-services-stream": "11.5.2",
     "@mojaloop/database-lib": "11.1.4",
     "@mojaloop/event-sdk": "14.4.0",
     "@mojaloop/inter-scheme-proxy-cache-lib": "2.4.0",
-    "@mojaloop/ml-schema-transformer-lib": "2.7.0",
+    "@mojaloop/ml-schema-transformer-lib": "2.7.1",
     "@mojaloop/sdk-standard-components": "19.11.3-snapshot.0",
     "@now-ims/hapi-now-auth": "2.1.0",
     "ajv": "8.17.1",

package/src/domain/parties/services/BasePartiesService.js

@@ -30,6 +30,7 @@ const { Enum } = require('@mojaloop/central-services-shared')
 const { decodePayload } = require('@mojaloop/central-services-shared').Util.StreamingProtocol
 const { initStepState } = require('../../../lib/util')
 const { createCallbackHeaders } = require('../../../lib/headers')
+const { ERROR_MESSAGES } = require('../../../constants')
 
 const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
 const { Headers, RestMethods } = Enum.Http
@@ -100,16 +101,17 @@ class BasePartiesService {
   get state () { return this.#state }
 
   async handleError (error) {
-    const { headers, params } = this.inputs
+    const { params } = this.inputs
     const log = this.log.child({ method: 'handleError' })
     try {
       log.error('error in processing parties request: ', error)
       const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(error)
-      const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, fspiopError, headers, params)
+      const callbackHeaders = BasePartiesService.createErrorCallbackHeaders(this.inputs.headers, params)
+      const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, fspiopError, callbackHeaders, params)
 
       await this.sendErrorCallback({
         errorInfo,
-        headers: BasePartiesService.createErrorCallbackHeaders(headers, params),
+        headers: callbackHeaders,
         params
       })
       log.info('handleError in done')
@@ -126,6 +128,27 @@ class BasePartiesService {
     return this.deps.participant.validateParticipant(participantId)
   }
 
+  async identifyDestinationForCallback () {
+    this.stepInProgress('identifyDestinationForCallback')
+    const { destination } = this.state
+
+    const schemeParticipant = await this.validateParticipant(destination)
+    if (schemeParticipant) {
+      this.state.requester = destination
+      return
+    }
+
+    const proxyName = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
+    if (proxyName) {
+      this.state.requester = proxyName
+      return
+    }
+
+    const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
+    this.log.warn(`${errMessage} and no proxy`, { destination })
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
+  }
+
   async sendErrorCallback ({ errorInfo, headers, params }) {
     this.stepInProgress('sendErrorCallback')
     const sendTo = this.state.requester || this.state.source

package/src/domain/parties/services/PutPartiesErrorService.js

@@ -25,8 +25,6 @@
  --------------
  ******/
 
-const ErrorHandler = require('@mojaloop/central-services-error-handling')
-const { ERROR_MESSAGES } = require('../../../constants')
 const BasePartiesService = require('./BasePartiesService')
 
 class PutPartiesErrorService extends BasePartiesService {
@@ -51,7 +49,7 @@ class PutPartiesErrorService extends BasePartiesService {
       }
     }
 
-    await this.identifyDestinationForErrorCallback()
+    await this.identifyDestinationForCallback()
     await this.sendErrorCallbackToParticipant()
     this.log.info('putPartiesByTypeAndID is done')
   }
@@ -72,27 +70,6 @@ class PutPartiesErrorService extends BasePartiesService {
     return isLast
   }
 
-  async identifyDestinationForErrorCallback () {
-    this.stepInProgress('identifyDestinationForErrorCallback')
-    const { destination } = this.state
-    const schemeParticipant = await super.validateParticipant(destination)
-    if (schemeParticipant) {
-      this.state.requester = destination
-      return
-    }
-
-    this.stepInProgress('lookupProxyDestination-4')
-    const proxyName = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
-    if (proxyName) {
-      this.state.requester = proxyName
-      return
-    }
-
-    const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-    this.log.warn(errMessage, { destination })
-    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
-  }
-
   async sendErrorCallbackToParticipant () {
     const { headers, params, dataUri } = this.inputs
     const errorInfo = PutPartiesErrorService.decodeDataUriPayload(dataUri)

package/src/domain/parties/services/PutPartiesService.js

@@ -25,7 +25,6 @@
  --------------
  ******/
 
-const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const { ERROR_MESSAGES } = require('../../../constants')
 const BasePartiesService = require('./BasePartiesService')
 
@@ -40,7 +39,7 @@ class PutPartiesService extends BasePartiesService {
     if (proxy) {
       await this.checkProxySuccessResponse()
     }
-    await this.identifyDestinationForSuccessCallback()
+    await this.identifyDestinationForCallback()
     await this.sendSuccessCallback()
   }
 
@@ -85,25 +84,6 @@ class PutPartiesService extends BasePartiesService {
     }
   }
 
-  async identifyDestinationForSuccessCallback () {
-    const { destination } = this.state
-    this.stepInProgress('identifyDestinationForSuccessCallback')
-    const destinationParticipant = await super.validateParticipant(destination)
-    if (destinationParticipant) {
-      this.state.requester = destinationParticipant.name
-      return
-    }
-
-    const proxyName = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
-    if (!proxyName) {
-      const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-      this.log.warn(`${errMessage} and no proxy`, { destination })
-      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
-    }
-
-    this.state.requester = proxyName
-  }
-
   async sendSuccessCallback () {
     const { headers, params, dataUri } = this.inputs
     const sendTo = this.state.requester

package/src/domain/parties/services/TimeoutPartiesService.js

@@ -52,7 +52,7 @@ class TimeoutPartiesService extends PutPartiesErrorService {
     const { errorInfo, headers, params } = await this.prepareErrorInformation()
     this.#spanAuditStart(errorInfo)
 
-    await this.identifyDestinationForErrorCallback()
+    await this.identifyDestinationForCallback()
     return super.sendErrorCallback({ errorInfo, headers, params })
   }
 

package/test/unit/domain/parties/parties.test.js

@@ -587,20 +587,20 @@ describe('Parties Tests', () => {
     it('successfully sends the callback to the participant', async () => {
       expect.hasAssertions()
       // Arrange
-      participant.validateParticipant = sandbox.stub().resolves({
-        name: 'fsp1'
-      })
+      participant.validateParticipant = sandbox.stub().resolves({})
       participant.sendRequest = sandbox.stub().resolves()
       const payload = JSON.stringify({ testPayload: true })
       const dataUri = encodePayload(payload, 'application/json')
+      const destination = 'destFsp'
+      const headers = fixtures.partiesCallHeadersDto({ destination })
 
       // Act
-      await partiesDomain.putPartiesByTypeAndID(Helper.putByTypeIdRequest.headers, Helper.putByTypeIdRequest.params, 'put', payload, dataUri, null, proxyCache)
+      await partiesDomain.putPartiesByTypeAndID(headers, Helper.putByTypeIdRequest.params, 'put', payload, dataUri, null, proxyCache)
 
       // Assert
       expect(participant.sendRequest.callCount).toBe(1)
       const sendRequestCallArgs = participant.sendRequest.getCall(0).args
-      expect(sendRequestCallArgs[1]).toStrictEqual('fsp1')
+      expect(sendRequestCallArgs[1]).toBe(destination)
       participant.sendRequest.reset()
     })
 

package/test/unit/domain/parties/services/BasePartiesService.test.js

@@ -54,7 +54,8 @@ describe('BasePartiesService Tests -->', () => {
     expect(sentTo).toBe(source)
     expect(payload.Rpt.Rsn.Cd).toBe('2001')
     expect(payload.Rpt.OrgnlId).toBe(`${params.Type}/${params.ID}`)
-    expect(payload.Assgnmt.Assgnr.Agt.FinInstnId.Othr.Id).toBe(source)
+    expect(payload.Assgnmt.Assgne.Agt.FinInstnId.Othr.Id).toBe(source)
+    expect(payload.Assgnmt.Assgnr.Agt.FinInstnId.Othr.Id).toBe(config.HUB_NAME)
   })
 
   test('should remove proxy getParties timeout cache key', async () => {

package/test/unit/domain/parties/services/GetPartiesService.test.js

@@ -199,15 +199,18 @@ describe('GetPartiesService Tests -->', () => {
       expect(participantMock.sendRequest.mock.lastCall[1]).toBe(proxyOk)
     })
 
-    test('should throw an error if proxyRequest failed after delay, and other proxies have already replied', async () => {
-      expect.assertions(1)
+    const throwDelayedErrorOnNthCall = (N, delay = 1000, error = new Error('Nth call Delayed Error')) => {
       let count = 0
-      participantMock.sendRequest = jest.fn(async () => {
+      return async () => {
         count++
-        if (count !== 2) return {}
-        await sleep(1000) // throw delayed error for 2nd proxy call
-        throw new Error('Proxy delayed error')
-      })
+        if (count !== N) return {}
+        await sleep(1000)
+        throw error
+      }
+    }
+
+    const prepareGetPartiesServiceForDelayedProxyError = () => {
+      participantMock.sendRequest = jest.fn(throwDelayedErrorOnNthCall(2)) // throw error on 2nd proxy call
       const proxies = createProxiesUtilMock({
         getAllProxiesNames: jest.fn().mockResolvedValue(['proxy1', 'proxy2'])
       })
@@ -215,14 +218,31 @@ describe('GetPartiesService Tests -->', () => {
         receivedErrorResponse: jest.fn().mockResolvedValue(true) // failed proxy request is last in inter-scheme discovery flow
       })
       const deps = createMockDeps({ proxies, proxyCache })
-
       const headers = fixtures.partiesCallHeadersDto({ destination: '' })
       const params = fixtures.partiesParamsDto()
-      const service = new GetPartiesService(deps, { headers, params })
+
+      return new GetPartiesService(deps, { headers, params })
+    }
+
+    test('should throw an error if proxyRequest failed after delay, and other proxies have already replied', async () => {
+      expect.assertions(1)
+      const service = prepareGetPartiesServiceForDelayedProxyError()
+      const { headers } = service.inputs
 
       await expect(service.triggerInterSchemeDiscoveryFlow(headers))
         .rejects.toThrow(ERROR_MESSAGES.noSuccessfulProxyDiscoveryResponses)
     })
+
+    test('should send error callback in ISO format if proxyRequest failed after delay, and other proxies have already replied', async () => {
+      const service = prepareGetPartiesServiceForDelayedProxyError()
+      const { headers } = service.inputs
+      service.deps.config.API_TYPE = API_TYPES.iso20022
+
+      await service.triggerInterSchemeDiscoveryFlow(headers)
+        .catch(err => service.handleError(err))
+      expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+      expect(participantMock.sendErrorToParticipant.mock.lastCall[2].Rpt.Rsn.Cd).toBe('3200')
+    })
   })
 
   describe('setProxyGetPartiesTimeout Tests', () => {