account-lookup-service 17.8.0-snapshot.10 → 17.8.0-snapshot.100

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.10",
+  "version": "17.8.0-snapshot.100",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
@@ -92,9 +92,9 @@
     "@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",
@@ -106,7 +106,7 @@
     "ajv-keywords": "5.1.0",
     "blipp": "4.0.2",
     "commander": "13.1.0",
-    "cron": "4.1.2",
+    "cron": "4.1.3",
     "fast-safe-stringify": "^2.1.1",
     "hapi-auth-bearer-token": "8.0.0",
     "joi": "17.13.3",

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

@@ -100,16 +100,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')

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

@@ -61,10 +61,12 @@ class GetPartiesService extends BasePartiesService {
     const log = this.log.child({ source, proxy, method: 'validateRequester' })
     this.stepInProgress('validateRequester-0')
 
-    const schemeSource = await this.validateParticipant(source)
-    if (schemeSource) {
-      log.debug('source participant is in scheme')
-      return source
+    if (!(proxyEnabled && proxy)) {
+      const schemeSource = await this.validateParticipant(source)
+      if (schemeSource) {
+        log.debug('source participant is in scheme')
+        return source
+      }
     }
 
     if (!proxyEnabled || !proxy) {

package/src/server.js

@@ -45,7 +45,18 @@ const OracleEndpointCache = require('./models/oracle/oracleEndpointCached')
 const Handlers = require('./handlers/register')
 
 const connectDatabase = async (dbConfig) => {
-  return Db.connect(dbConfig)
+  await Db.connect(dbConfig)
+  logger.info('Database connected')
+}
+
+const initOpenApiBackend = async ({ isAdmin }) => {
+  const OpenAPISpecPath = Util.pathForInterface({ isAdmin, isMockInterface: false })
+  const apiHandlers = isAdmin
+    ? APIHandlers.AdminHandlers
+    : APIHandlers.ApiHandlers
+  const api = await OpenapiBackend.initialise(OpenAPISpecPath, apiHandlers)
+  logger.verbose('OpenAPI Backend initialized', { isAdmin })
+  return api
 }
 
 const migrate = async () => {
@@ -132,8 +143,7 @@ const initializeApi = async (appConfig) => {
     initializeInstrumentation(INSTRUMENTATION_METRICS_CONFIG)
   }
   await connectDatabase(DATABASE)
-  const OpenAPISpecPath = Util.pathForInterface({ isAdmin: false, isMockInterface: false })
-  const api = await OpenapiBackend.initialise(OpenAPISpecPath, APIHandlers.ApiHandlers)
+  const api = await initOpenApiBackend({ isAdmin: false })
 
   await Promise.all([
     Endpoints.initializeCache(CENTRAL_SHARED_ENDPOINT_CACHE_CONFIG, Util.hubNameConfig),
@@ -142,6 +152,7 @@ const initializeApi = async (appConfig) => {
     OracleEndpointCache.initialize(),
     Cache.initCache()
   ])
+  logger.verbose('all caches initialized')
 
   return createServer(API_PORT, api, Routes.APIRoutes(api), false, PROXY_CACHE_CONFIG)
 }
@@ -161,8 +172,8 @@ const initializeAdmin = async (appConfig) => {
   }
   await connectDatabase(DATABASE)
   RUN_MIGRATIONS && await migrate()
-  const OpenAPISpecPath = Util.pathForInterface({ isAdmin: true, isMockInterface: false })
-  const api = await OpenapiBackend.initialise(OpenAPISpecPath, APIHandlers.AdminHandlers)
+  const api = await initOpenApiBackend({ isAdmin: true })
+
   await Promise.all([
     OracleEndpointCache.initialize(),
     Cache.initCache()

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

@@ -174,8 +174,7 @@ describe('Parties Tests', () => {
     it('should set source proxyMapping if source is not in scheme, and there is proxy-header', async () => {
       Config.PROXY_CACHE_CONFIG.enabled = true
       participant.validateParticipant = sandbox.stub()
-        .onFirstCall().resolves(null) // source
-        .onSecondCall().resolves({}) // proxy
+        .onFirstCall().resolves({}) // proxy, source is skipped
       const source = `source-${Date.now()}`
       const proxy = `proxy-${Date.now()}`
 

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

@@ -99,6 +99,9 @@ describe('GetPartiesService Tests -->', () => {
     })
 
     test('should cleanup oracle and trigger interScheme discovery, if no proxyMapping for external dfsp', async () => {
+      participantMock.validateParticipant = jest.fn()
+        .mockResolvedValueOnce({}) // proxy, source is skipped
+
       proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValueOnce(null)
       const headers = fixtures.partiesCallHeadersDto({
         destination: '', proxy: 'proxyA'
@@ -114,6 +117,8 @@ describe('GetPartiesService Tests -->', () => {
     })
 
     test('should trigger interScheme discovery flow, if source is external', async () => {
+      participantMock.validateParticipant = jest.fn()
+        .mockResolvedValueOnce({}) // proxy, source is skipped
       const headers = fixtures.partiesCallHeadersDto({
         destination: '', proxy: 'proxyA'
       })
@@ -199,15 +204,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 +223,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', () => {
@@ -247,8 +272,7 @@ describe('GetPartiesService Tests -->', () => {
 
     test('should NOT set getParties timeout if source is external', async () => {
       participantMock.validateParticipant = jest.fn()
-        .mockResolvedValueOnce(null) // source
-        .mockResolvedValueOnce({}) // proxy-src
+        .mockResolvedValueOnce({}) // proxy, source is skipped
       const proxyCache = createProxyCacheMock({
         lookupProxyByDfspId: jest.fn().mockResolvedValue('proxy-desc')
       })