account-lookup-service 17.7.0-snapshot.2 → 17.7.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.7.0-snapshot.2",
+  "version": "17.7.0-snapshot.5",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
@@ -92,7 +92,7 @@
     "@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.7.0",
+    "@mojaloop/central-services-logger": "11.8.0",
     "@mojaloop/central-services-metrics": "12.5.0",
     "@mojaloop/central-services-shared": "18.23.1",
     "@mojaloop/central-services-stream": "11.5.2",

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

@@ -142,9 +142,9 @@ class BasePartiesService {
     return this.deps.oracle.oracleRequest(headers, RestMethods.DELETE, params, null, null, this.deps.cache)
   }
 
-  async removeProxyGetPartiesTimeout (alsReq) {
-    const isRemoved = await this.deps.proxyCache.removeProxyGetPartiesTimeout(alsReq)
-    this.log.debug('removeProxyGetPartiesTimeout is done', { isRemoved, alsReq })
+  async removeProxyGetPartiesTimeoutCache (alsReq) {
+    const isRemoved = await this.deps.proxyCache.removeProxyGetPartiesTimeout(alsReq, this.state.proxy)
+    this.log.debug('removeProxyGetPartiesTimeoutCache is done', { isRemoved, alsReq })
     return isRemoved
   }
 

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

@@ -282,13 +282,12 @@ class GetPartiesService extends BasePartiesService {
   async #setProxyGetPartiesTimeout (sendTo) {
     const isLocalSource = this.isLocalSource()
     const isSentToProxy = this.state.destination !== sendTo
-    this.log.verbose('isLocalSource and isSentToProxy: ', { isLocalSource, isSentToProxy })
+    this.log.verbose('isLocalSource and isSentToProxy: ', { isLocalSource, isSentToProxy, sendTo })
 
     if (isSentToProxy && isLocalSource) {
       this.stepInProgress('#setProxyGetPartiesTimeout')
-      const { source, proxy } = this.state
-      const alsReq = this.deps.partiesUtils.alsRequestDto(source, this.inputs.params)
-      const isSet = await this.deps.proxyCache.setProxyGetPartiesTimeout(alsReq, proxy)
+      const alsReq = this.deps.partiesUtils.alsRequestDto(this.state.source, this.inputs.params)
+      const isSet = await this.deps.proxyCache.setProxyGetPartiesTimeout(alsReq, sendTo)
       this.log.info('#setProxyGetPartiesTimeout is done', { isSet })
       return isSet
     }

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

@@ -39,7 +39,7 @@ class PutPartiesErrorService extends BasePartiesService {
         // not initial inter-scheme discovery case. Cleanup oracle and trigger inter-scheme discovery
         this.log.warn('Need to cleanup oracle and trigger new inter-scheme discovery flow')
         await this.cleanupOracle()
-        await this.removeProxyGetPartiesTimeout(alsReq)
+        await this.removeProxyGetPartiesTimeoutCache(alsReq)
         return true // need to trigger inter-scheme discovery
       }
 

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

@@ -74,7 +74,7 @@ class PutPartiesService extends BasePartiesService {
       const isExists = await this.deps.proxyCache.receivedSuccessResponse(alsReq)
       if (!isExists) {
         this.log.verbose('NOT inter-scheme receivedSuccessResponse case')
-        await this.removeProxyGetPartiesTimeout(alsReq)
+        await this.removeProxyGetPartiesTimeoutCache(alsReq)
         return
       }
 

package/src/domain/timeout/index.js

@@ -44,15 +44,17 @@ const Metrics = require('@mojaloop/central-services-metrics')
 
 const Participant = require('../../models/participantEndpoint/facade')
 const { ERROR_MESSAGES } = require('../../constants')
-const { timeoutCallbackDto } = require('./dto')
 const { logger } = require('../../lib')
-const util = require('../../lib/util')
+const { countFspiopError } = require('../../lib/util')
+const { timeoutCallbackDto } = require('./dto')
 
 const timeoutInterschemePartiesLookups = async ({ proxyCache, batchSize }) => {
+  logger.info('timeoutInterschemePartiesLookups start...', { batchSize })
   return proxyCache.processExpiredAlsKeys(sendTimeoutCallback, batchSize)
 }
 
 const timeoutProxyGetPartiesLookups = async ({ proxyCache, batchSize }) => {
+  logger.info('timeoutProxyGetPartiesLookups start...', { batchSize })
   return proxyCache.processExpiredProxyGetPartiesKeys(sendTimeoutCallback, batchSize)
 }
 
@@ -65,31 +67,32 @@ const sendTimeoutCallback = async (cacheKey) => {
   let step
   const [destination, partyType, partyId] = parseCacheKey(cacheKey)
   const { errorInformation, params, headers, endpointType, span } = await timeoutCallbackDto({ destination, partyId, partyType })
-  logger.debug('sendTimeoutCallback details:', { destination, partyType, partyId, cacheKey })
+  const log = logger.child({ destination, partyId })
+  log.verbose('sendTimeoutCallback details:', { errorInformation, cacheKey, partyType })
 
   try {
     step = 'validateParticipant-1'
-    await validateParticipant(destination)
+    await validateParticipant(destination, log)
     await span.audit({ headers, errorInformation }, AuditEventAction.start)
     step = 'sendErrorToParticipant-2'
     await Participant.sendErrorToParticipant(destination, endpointType, errorInformation, headers, params, undefined, span)
     histTimerEnd({ success: true })
   } catch (err) {
-    logger.warn('error in sendTimeoutCallback: ', err)
+    log.warn('error in sendTimeoutCallback: ', err)
     histTimerEnd({ success: false })
     const fspiopError = reformatFSPIOPError(err)
-    util.countFspiopError(fspiopError, { operation: 'sendTimeoutCallback', step })
+    countFspiopError(fspiopError, { operation: 'sendTimeoutCallback', step })
 
     await finishSpan(span, fspiopError)
     throw fspiopError
   }
 }
 
-const validateParticipant = async (fspId) => {
+const validateParticipant = async (fspId, log) => {
   const participant = await Participant.validateParticipant(fspId)
   if (!participant) {
     const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-    logger.error(`error in validateParticipant: ${errMessage}`)
+    log.error(`error in validateParticipant: ${errMessage}`)
     throw createFSPIOPError(FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
   }
   return participant

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

@@ -56,4 +56,16 @@ describe('BasePartiesService Tests -->', () => {
     expect(payload.Rpt.OrgnlId).toBe(`${params.Type}/${params.ID}`)
     expect(payload.Assgnmt.Assgnr.Agt.FinInstnId.Othr.Id).toBe(source)
   })
+
+  test('should remove proxy getParties timeout cache key', async () => {
+    const deps = createMockDeps()
+    const proxy = 'proxyAB'
+    const headers = fixtures.partiesCallHeadersDto({ proxy })
+    const params = fixtures.partiesParamsDto()
+    const alsReq = {}
+    const service = new BasePartiesService(deps, { headers, params })
+
+    await service.removeProxyGetPartiesTimeoutCache(alsReq)
+    expect(deps.proxyCache.removeProxyGetPartiesTimeout).toHaveBeenCalledWith(alsReq, proxy)
+  })
 })

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

@@ -156,8 +156,9 @@ describe('GetPartiesService Tests -->', () => {
       participantMock.validateParticipant = jest.fn()
         .mockResolvedValueOnce({}) // source
         .mockResolvedValueOnce(null) // destination
+      const proxyId = 'proxy-destination'
       const proxyCache = createProxyCacheMock({
-        lookupProxyByDfspId: jest.fn().mockResolvedValueOnce('proxy-dest')
+        lookupProxyByDfspId: jest.fn().mockResolvedValueOnce(proxyId)
       })
       const deps = createMockDeps({ proxyCache })
       const headers = fixtures.partiesCallHeadersDto()
@@ -166,6 +167,7 @@ describe('GetPartiesService Tests -->', () => {
 
       await service.handleRequest()
       expect(proxyCache.setProxyGetPartiesTimeout).toHaveBeenCalledTimes(1)
+      expect(proxyCache.setProxyGetPartiesTimeout.mock.lastCall[1]).toBe(proxyId)
       expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
     })