account-lookup-service 17.13.0-snapshot.3 → 17.13.0-snapshot.5

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.13.0-snapshot.3",
+  "version": "17.13.0-snapshot.5",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
@@ -95,13 +95,13 @@
     "@mojaloop/central-services-health": "15.1.0",
     "@mojaloop/central-services-logger": "11.9.3",
     "@mojaloop/central-services-metrics": "12.7.1",
-    "@mojaloop/central-services-shared": "18.32.1",
+    "@mojaloop/central-services-shared": "18.33.0",
     "@mojaloop/central-services-stream": "11.8.7",
     "@mojaloop/database-lib": "^11.3.2",
     "@mojaloop/event-sdk": "14.7.0",
     "@mojaloop/inter-scheme-proxy-cache-lib": "2.6.0",
     "@mojaloop/ml-schema-transformer-lib": "2.7.8",
-    "@mojaloop/sdk-standard-components": "19.16.8",
+    "@mojaloop/sdk-standard-components": "19.16.9",
     "@now-ims/hapi-now-auth": "2.1.0",
     "ajv": "8.17.1",
     "ajv-keywords": "5.1.0",

package/src/constants.js

@@ -29,7 +29,7 @@ const { API_TYPES } = require('@mojaloop/central-services-shared').Util.Hapi
 
 const ERROR_MESSAGES = Object.freeze({
   emptyFilteredPartyList: 'Empty oracle partyList, filtered based on callbackEndpointType',
-  externalPartyError: 'External party error', // todo: think better message
+  externalPartyError: 'External party resolution error',
   failedToCacheSendToProxiesList: 'Failed to cache sendToProxiesList',
   noDiscoveryRequestsForwarded: 'No discovery requests forwarded to participants',
   sourceFspNotFound: 'Requester FSP not found',

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

@@ -170,6 +170,26 @@ class BasePartiesService {
     this.log.info('sendErrorCallback is done', { sendTo, errorInfo })
   }
 
+  /**
+   * @returns {Promise<{ fspId: string, partySubIdOrType?: string }[]>} List of parties from oracle response
+   */
+  async sendOracleDiscoveryRequest () {
+    this.stepInProgress('#sendOracleDiscoveryRequest')
+    const { headers, params, query } = this.inputs
+
+    const response = await this.deps.oracle.oracleRequest(headers, RestMethods.GET, params, query, undefined, this.deps.cache)
+    this.log.verbose('oracle discovery raw response:', { response })
+
+    let { partyList } = response?.data || {}
+    if (!Array.isArray(partyList)) {
+      this.log.warn('invalid oracle discovery response:', { response })
+      // todo: maybe, it's better to throw an error
+      partyList = []
+    }
+
+    return partyList
+  }
+
   async sendDeleteOracleRequest (headers, params) {
     this.stepInProgress('sendDeleteOracleRequest')
     const result = await this.deps.oracle.oracleRequest(headers, RestMethods.DELETE, params, null, null, this.deps.cache)

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

@@ -28,7 +28,7 @@
 const { ERROR_MESSAGES } = require('../../../constants')
 const BasePartiesService = require('./BasePartiesService')
 
-const { FspEndpointTypes, RestMethods } = BasePartiesService.enums()
+const { RestMethods } = BasePartiesService.enums()
 const proxyCacheTtlSec = 40 // todo: make configurable
 
 class GetPartiesService extends BasePartiesService {
@@ -45,8 +45,8 @@ class GetPartiesService extends BasePartiesService {
       return
     }
 
-    const response = await this.sendOracleDiscoveryRequest()
-    const isSent = await this.processOraclePartyListResponse(response)
+    const partyList = await this.sendOracleDiscoveryRequest()
+    const isSent = await this.processOraclePartyListResponse(partyList)
     this.log.info(`getParties request is ${isSent ? '' : 'NOT '}forwarded to oracle lookup DFSP`)
     if (isSent) return
 
@@ -117,20 +117,14 @@ class GetPartiesService extends BasePartiesService {
     log.info('discovery getPartiesByTypeAndID request was sent', { sendTo })
   }
 
-  async sendOracleDiscoveryRequest () {
-    this.stepInProgress('#sendOracleDiscoveryRequest')
-    const { headers, params, query } = this.inputs
-    return this.deps.oracle.oracleRequest(headers, RestMethods.GET, params, query, undefined, this.deps.cache)
-  }
-
-  async processOraclePartyListResponse (response) {
-    if (!Array.isArray(response?.data?.partyList) || response.data.partyList.length === 0) {
+  async processOraclePartyListResponse (rawPartyList) {
+    if (rawPartyList.length === 0) {
       this.log.verbose('oracle partyList is empty')
       return false
     }
 
     this.stepInProgress('processOraclePartyList')
-    const partyList = this.#filterOraclePartyList(response)
+    const partyList = this.#filterOraclePartyList(rawPartyList)
 
     let sentCount = 0
     await Promise.all(partyList.map(async party => {
@@ -174,28 +168,20 @@ class GetPartiesService extends BasePartiesService {
     return isLocal
   }
 
-  #filterOraclePartyList (response) {
+  #filterOraclePartyList (partyList) {
     // Oracle's API is a standard rest-style end-point Thus a GET /party on the oracle will return all participant-party records.
     // We must filter the results based on the callbackEndpointType to make sure we remove records containing partySubIdOrType when we are in FSPIOP_CALLBACK_URL_PARTIES_GET mode:
-    this.stepInProgress('filterOraclePartyList')
+    this.stepInProgress('#filterOraclePartyList')
     const { params } = this.inputs
-    const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
-    let filteredPartyList
-
-    switch (callbackEndpointType) {
-      case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_GET:
-        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType == null) // Filter records that DON'T contain a partySubIdOrType
-        break
-      case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_SUB_ID_GET:
-        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
-        break
-      default:
-        filteredPartyList = response // Fallback to providing the standard list
-    }
 
-    if (!Array.isArray(filteredPartyList) || !filteredPartyList.length) {
+    const filteredPartyList = !params?.SubId
+      ? partyList.filter(party => party.partySubIdOrType == null) // Filter records that DON'T contain a partySubIdOrType
+      : partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
+
+    if (!filteredPartyList.length) {
       throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.emptyFilteredPartyList)
     }
+    this.log.verbose('#filterOraclePartyList is done:', { filteredPartyList })
 
     return filteredPartyList
   }
@@ -338,13 +324,13 @@ class GetPartiesService extends BasePartiesService {
     log.verbose('needOracleValidation: ', { needValidation })
     if (!needValidation) return true
 
-    const oracleResponse = await this.sendOracleDiscoveryRequest()
-    if (!Array.isArray(oracleResponse?.data?.partyList) || oracleResponse.data.partyList.length === 0) {
+    const partyList = await this.sendOracleDiscoveryRequest()
+    if (partyList.length === 0) {
       log.warn('Oracle returned empty party list')
       return false
     }
 
-    const isValid = oracleResponse.data.partyList.some(party => party.fspId === state.destination)
+    const isValid = partyList.some(party => party.fspId === state.destination)
     log.verbose('#validateLocalDestinationForExternalSource is done', { isValid })
     return isValid
   }

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

@@ -41,9 +41,9 @@ class PutPartiesErrorService extends BasePartiesService {
           return
         }
       } else {
-        const schemeParticipant = await this.validateParticipant(this.state.destination)
-        if (!schemeParticipant) {
-          this.log.info('Need to cleanup oracle and forward SERVICE_CURRENTLY_UNAVAILABLE error')
+        const isExternal = await this.#isPartyFromExternalDfsp()
+        if (isExternal) {
+          this.log.info('Need to cleanup oracle and forward PARTY_RESOLUTION_FAILURE error')
           await this.cleanupOracle()
           await this.removeProxyGetPartiesTimeoutCache(alsReq)
           await this.#sendPartyResolutionErrorCallback()
@@ -79,6 +79,20 @@ class PutPartiesErrorService extends BasePartiesService {
     return super.sendErrorCallback({ errorInfo, headers, params })
   }
 
+  async #isPartyFromExternalDfsp () {
+    this.stepInProgress('#isPartyFromExternalDfsp')
+    const partyList = await super.sendOracleDiscoveryRequest()
+    if (!partyList.length) {
+      this.log.verbose('oracle returns empty partyList')
+      return false
+    }
+    // think, if we have several parties from oracle
+    const isExternal = !(await this.validateParticipant(partyList[0].fspId))
+    this.log.verbose('#isPartyFromExternalDfsp is done:', { isExternal, partyList })
+
+    return isExternal
+  }
+
   async #sendPartyResolutionErrorCallback () {
     this.stepInProgress('#sendPartyResolutionErrorCallback')
     const { headers, params } = this.inputs

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

@@ -958,11 +958,13 @@ describe('Parties Tests', () => {
       oracleEndpointCached.getOracleEndpointByType = sandbox.stub().resolves([
         { value: 'http://oracle.endpoint' }
       ])
-      oracle.oracleRequest = sandbox.stub().resolves()
+      oracle.oracleRequest = sandbox.stub().resolves({
+        data: { partyList: [{ fspId: 'fspId' }] }
+      })
 
       await partiesDomain.putPartiesErrorByTypeAndID(headers, params, payload, '', null, null, proxyCache)
 
-      expect(oracle.oracleRequest.callCount).toBe(1)
+      expect(oracle.oracleRequest.callCount).toBe(2)
       expect(oracle.oracleRequest.lastCall.args[1]).toBe(RestMethods.DELETE)
       expect(participant.sendRequest.callCount).toBe(0)
       expect(participant.sendErrorToParticipant.callCount).toBe(1)

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

@@ -25,36 +25,44 @@
  --------------
  ******/
 
-const { createMockDeps, oracleMock, participantMock } = require('./deps')
-// ↑ should be first require to mock external deps ↑
 const { PutPartiesErrorService } = require('#src/domain/parties/services/index')
+const { createMockDeps, createOracleFacadeMock, createParticipantFacadeMock } = require('./deps')
 const fixtures = require('#test/fixtures/index')
 
 const { RestMethods, Headers } = PutPartiesErrorService.enums()
 
 describe('PutPartiesErrorService Tests -->', () => {
+  let oracle
+  let participant
+
   beforeEach(() => {
     jest.clearAllMocks()
+    oracle = createOracleFacadeMock()
+    participant = createParticipantFacadeMock()
   })
 
   test('should cleanup oracle and forward PARTY_RESOLUTION_FAILURE error for party from external dfsp', async () => {
-    participantMock.validateParticipant = jest.fn().mockRejectedValue(new Error('No participant found')) // external participant
+    participant.validateParticipant = jest.fn().mockRejectedValue(new Error('No participant found')) // external participant
+    oracle.oracleRequest = jest.fn().mockResolvedValue({
+      data: { partyList: [{ fspId: 'fspId' }] }
+    })
     const destination = 'externalDfsp'
     const proxyDest = 'proxyDest'
-    const deps = createMockDeps()
+    const deps = createMockDeps({ oracle, participant })
     deps.proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValue(proxyDest)
 
     const headers = fixtures.partiesCallHeadersDto({ destination, proxy: 'proxyA' })
     const params = fixtures.partiesParamsDto()
     const dataUri = fixtures.dataUriDto()
-    const service = new PutPartiesErrorService(deps, { headers, params, dataUri })
 
+    const service = new PutPartiesErrorService(deps, { headers, params, dataUri })
     await service.handleRequest()
-    expect(oracleMock.oracleRequest).toHaveBeenCalledTimes(1)
-    expect(oracleMock.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
-    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
-    // eslint-disable-next-line no-unused-vars
-    const [sentTo, _, payload, cbHeaders] = participantMock.sendErrorToParticipant.mock.lastCall
+
+    expect(oracle.oracleRequest).toHaveBeenCalledTimes(2)
+    expect(oracle.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
+    expect(participant.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+
+    const [sentTo, , payload, cbHeaders] = participant.sendErrorToParticipant.mock.lastCall
     expect(sentTo).toBe(proxyDest)
     expect(cbHeaders[Headers.FSPIOP.DESTINATION]).toBe(destination)
     expect(payload.errorInformation.errorCode).toBe('2006')
@@ -62,8 +70,8 @@ describe('PutPartiesErrorService Tests -->', () => {
 
   test('should NOT cleanup oracle if destination is local', async () => {
     const destination = 'localDfsp'
-    const deps = createMockDeps()
-    deps.participant.validateParticipant = jest.fn().mockResolvedValue({})
+    participant.validateParticipant = jest.fn().mockResolvedValue({})
+    const deps = createMockDeps({ participant })
 
     const headers = fixtures.partiesCallHeadersDto({ destination })
     const params = fixtures.partiesParamsDto()
@@ -71,8 +79,8 @@ describe('PutPartiesErrorService Tests -->', () => {
     const service = new PutPartiesErrorService(deps, { headers, params, dataUri })
 
     await service.handleRequest()
-    expect(oracleMock.oracleRequest).not.toHaveBeenCalled()
-    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
-    expect(participantMock.sendErrorToParticipant.mock.lastCall[0]).toBe(destination)
+    expect(oracle.oracleRequest).not.toHaveBeenCalled()
+    expect(participant.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+    expect(participant.sendErrorToParticipant.mock.lastCall[0]).toBe(destination)
   })
 })