account-lookup-service 17.7.0-snapshot.5 → 17.8.0-snapshot.6

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [17.7.0](https://github.com/mojaloop/account-lookup-service/compare/v17.6.0...v17.7.0) (2025-03-26)
+
+
+### Features
+
+* update dependencies to latest versions ([#542](https://github.com/mojaloop/account-lookup-service/issues/542)) ([8867742](https://github.com/mojaloop/account-lookup-service/commit/8867742e5e599f9a0de05eae095e2bd12e37d149))
+
 ## [17.6.0](https://github.com/mojaloop/account-lookup-service/compare/v17.5.0...v17.6.0) (2025-03-19)
 
 

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

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

@@ -186,9 +186,8 @@ class BasePartiesService {
   }
 
   static overrideDestinationHeader (headers, destination) {
-    const { [Headers.FSPIOP.DESTINATION]: _, ...restHeaders } = headers || {}
     return {
-      ...restHeaders,
+      ...BasePartiesService.headersWithoutDestination(headers),
       ...(destination && { [Headers.FSPIOP.DESTINATION]: destination })
     }
   }
@@ -204,6 +203,13 @@ class BasePartiesService {
     })
   }
 
+  static createHubErrorCallbackHeaders (hubName, destination) {
+    return {
+      [Headers.FSPIOP.SOURCE]: hubName,
+      [Headers.FSPIOP.DESTINATION]: destination
+    }
+  }
+
   static enums () {
     return {
       FspEndpointTypes,

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

@@ -0,0 +1,84 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const { AuditEventAction } = require('@mojaloop/event-sdk')
+const createSpan = require('../../timeout/createSpan') // todo: think, how to avoid this external deps
+const PutPartiesErrorService = require('./PutPartiesErrorService')
+
+class TimeoutPartiesService extends PutPartiesErrorService {
+  /**
+   *  Should be used to get TimeoutPartiesService instance
+   *
+   * @param deps {PartiesDeps}
+   * @param cacheKey {string}
+   * @param spanName {string}
+   * @returns {TimeoutPartiesService}
+   */
+  static createInstance (deps, cacheKey, spanName) {
+    const { destination, partyType, partyId } = TimeoutPartiesService.parseExpiredKey(cacheKey)
+    const headers = TimeoutPartiesService.createHubErrorCallbackHeaders(deps.config.HUB_NAME, destination)
+    const params = { Type: partyType, ID: partyId } // todo: think, if we need to handle party SubId
+    const childSpan = createSpan(spanName, headers, params)
+
+    return new TimeoutPartiesService({ ...deps, childSpan }, { headers, params })
+  }
+
+  async handleExpiredKey () {
+    const { errorInfo, headers, params } = await this.prepareErrorInformation()
+    this.#spanAuditStart(errorInfo)
+
+    await this.identifyDestinationForErrorCallback()
+    return super.sendErrorCallback({ errorInfo, headers, params })
+  }
+
+  async prepareErrorInformation () {
+    const { headers, params } = this.inputs
+    const error = TimeoutPartiesService.createFSPIOPExpiredError()
+    const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(
+      this.deps.config, error, headers, params
+    )
+    this.log.verbose('prepareErrorInformation is done', { errorInfo, headers, params })
+    return { errorInfo, headers, params }
+  }
+
+  #spanAuditStart (errorInformation) {
+    const { headers } = this.inputs
+    this.deps.childSpan?.audit({ errorInformation, headers }, AuditEventAction.start)
+  }
+
+  static parseExpiredKey (cacheKey) {
+    const [destination, partyType, partyId] = cacheKey.split(':').slice(-3)
+    return { destination, partyType, partyId }
+  }
+
+  static createFSPIOPExpiredError () {
+    return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.EXPIRED_ERROR)
+  }
+}
+
+module.exports = TimeoutPartiesService

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

@@ -28,9 +28,11 @@
 const GetPartiesService = require('./GetPartiesService')
 const PutPartiesService = require('./PutPartiesService')
 const PutPartiesErrorService = require('./PutPartiesErrorService')
+const TimeoutPartiesService = require('./TimeoutPartiesService')
 
 module.exports = {
   GetPartiesService,
   PutPartiesService,
-  PutPartiesErrorService
+  PutPartiesErrorService,
+  TimeoutPartiesService
 }

package/src/domain/timeout/createSpan.js

@@ -0,0 +1,55 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const {
+  Events: { Event },
+  Tags: { QueryTags }
+} = require('@mojaloop/central-services-shared').Enum
+const { Tracer } = require('@mojaloop/event-sdk')
+const EventFrameworkUtil = require('@mojaloop/central-services-shared').Util.EventFramework
+
+const { getSpanTags } = require('../../lib/util')
+
+const createSpan = (spanName, headers, params) => {
+  const span = Tracer.createSpan(spanName, { headers })
+  const spanTags = getSpanTags({ headers }, Event.Type.PARTY, Event.Action.PUT)
+  span.setTags(spanTags)
+  const queryTags = EventFrameworkUtil.Tags.getQueryTags(
+    QueryTags.serviceName.accountLookupService,
+    QueryTags.auditType.transactionFlow,
+    QueryTags.contentType.httpRequest,
+    QueryTags.operation.timeoutInterschemePartiesLookups,
+    {
+      partyIdType: params.Type,
+      partyIdentifier: params.ID
+    }
+  )
+  span.setTags(queryTags)
+  return span
+}
+
+module.exports = createSpan

package/src/domain/timeout/index.js

@@ -31,73 +31,56 @@
  ******/
 'use strict'
 
-const {
-  Factory: { createFSPIOPError, reformatFSPIOPError },
-  Enums: { FSPIOPErrorCodes }
-} = require('@mojaloop/central-services-error-handling')
-const {
-  EventStateMetadata,
-  EventStatusType,
-  AuditEventAction
-} = require('@mojaloop/event-sdk')
+const { Factory: { reformatFSPIOPError } } = require('@mojaloop/central-services-error-handling')
+const { EventStateMetadata, EventStatusType } = require('@mojaloop/event-sdk')
 const Metrics = require('@mojaloop/central-services-metrics')
 
-const Participant = require('../../models/participantEndpoint/facade')
-const { ERROR_MESSAGES } = require('../../constants')
 const { logger } = require('../../lib')
 const { countFspiopError } = require('../../lib/util')
-const { timeoutCallbackDto } = require('./dto')
+const { createDeps } = require('../parties/deps')
+const { TimeoutPartiesService } = require('../parties/services')
 
 const timeoutInterschemePartiesLookups = async ({ proxyCache, batchSize }) => {
-  logger.info('timeoutInterschemePartiesLookups start...', { batchSize })
-  return proxyCache.processExpiredAlsKeys(sendTimeoutCallback, batchSize)
+  const operation = timeoutInterschemePartiesLookups.name
+  logger.info(`${operation} start...`, { batchSize })
+  return proxyCache.processExpiredAlsKeys(
+    (key) => sendTimeoutCallback(key, proxyCache, operation), batchSize
+  )
 }
 
 const timeoutProxyGetPartiesLookups = async ({ proxyCache, batchSize }) => {
-  logger.info('timeoutProxyGetPartiesLookups start...', { batchSize })
-  return proxyCache.processExpiredProxyGetPartiesKeys(sendTimeoutCallback, batchSize)
+  const operation = timeoutProxyGetPartiesLookups.name
+  logger.info(`${operation} start...`, { batchSize })
+  return proxyCache.processExpiredProxyGetPartiesKeys(
+    (key) => sendTimeoutCallback(key, proxyCache, operation), batchSize
+  )
 }
 
-const sendTimeoutCallback = async (cacheKey) => {
+const sendTimeoutCallback = async (cacheKey, proxyCache, operation) => {
   const histTimerEnd = Metrics.getHistogram(
     'eg_timeoutInterschemePartiesLookups',
     'Egress - Interscheme parties lookup timeout callback',
     ['success']
   ).startTimer()
-  let step
-  const [destination, partyType, partyId] = parseCacheKey(cacheKey)
-  const { errorInformation, params, headers, endpointType, span } = await timeoutCallbackDto({ destination, partyId, partyType })
-  const log = logger.child({ destination, partyId })
-  log.verbose('sendTimeoutCallback details:', { errorInformation, cacheKey, partyType })
+  const log = logger.child({ cacheKey, operation })
+  const deps = createDeps({ proxyCache, log })
+  const service = TimeoutPartiesService.createInstance(deps, cacheKey, operation)
+  const span = service.deps.childSpan
 
   try {
-    step = 'validateParticipant-1'
-    await validateParticipant(destination, log)
-    await span.audit({ headers, errorInformation }, AuditEventAction.start)
-    step = 'sendErrorToParticipant-2'
-    await Participant.sendErrorToParticipant(destination, endpointType, errorInformation, headers, params, undefined, span)
+    await service.handleExpiredKey()
     histTimerEnd({ success: true })
   } catch (err) {
     log.warn('error in sendTimeoutCallback: ', err)
     histTimerEnd({ success: false })
     const fspiopError = reformatFSPIOPError(err)
-    countFspiopError(fspiopError, { operation: 'sendTimeoutCallback', step })
+    countFspiopError(fspiopError, { operation, step: service?.currenStep })
 
     await finishSpan(span, fspiopError)
     throw fspiopError
   }
 }
 
-const validateParticipant = async (fspId, log) => {
-  const participant = await Participant.validateParticipant(fspId)
-  if (!participant) {
-    const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-    log.error(`error in validateParticipant: ${errMessage}`)
-    throw createFSPIOPError(FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
-  }
-  return participant
-}
-
 const finishSpan = async (span, err) => {
   if (!span.isFinished) {
     const state = new EventStateMetadata(
@@ -110,11 +93,6 @@ const finishSpan = async (span, err) => {
   }
 }
 
-const parseCacheKey = (cacheKey) => {
-  const [destination, partyType, partyId] = cacheKey.split(':').slice(-3)
-  return [destination, partyType, partyId]
-}
-
 module.exports = {
   timeoutInterschemePartiesLookups,
   timeoutProxyGetPartiesLookups,

package/test/fixtures/index.js

@@ -163,6 +163,13 @@ const mockAlsRequestDto = (sourceId, type, partyId) => ({
   partyId
 })
 
+const expiredCacheKeyDto = ({
+  sourceId = 'sourceId',
+  type = 'MSISDN',
+  partyId = 'partyId-123',
+  prefix = 'prefix'
+} = {}) => `${prefix}:${sourceId}:${type}:${partyId}`
+
 const mockHapiRequestDto = ({ // https://hapi.dev/api/?v=21.3.3#request-properties
   method = 'GET',
   traceid = randomUUID(),
@@ -185,6 +192,7 @@ module.exports = {
   putPartiesSuccessResponseDto,
   postParticipantsPayloadDto,
   errorCallbackResponseDto,
+  expiredCacheKeyDto,
   mockAlsRequestDto,
   protocolVersionsDto,
   mockHapiRequestDto,

package/test/integration/domain/timeout/index.test.js

@@ -1,18 +1,50 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
 const { createProxyCache } = require('@mojaloop/inter-scheme-proxy-cache-lib')
-const { PAYER_DFSP, PARTY_ID_TYPE, PROXY_NAME } = require('../../constants')
+const { RedisProxyCache } = require('@mojaloop/inter-scheme-proxy-cache-lib/dist/lib/storages/RedisProxyCache')
+const config = require('#src/lib/config')
 const fixtures = require('../../../fixtures')
 const { ProxyApiClient } = require('../../../util')
-const config = require('../../../../src/lib/config')
+const { PAYER_DFSP, PARTY_ID_TYPE, PROXY_NAME } = require('../../constants')
 
 const wait = (sec) => new Promise(resolve => setTimeout(resolve, sec * 1000))
 
 const CRON_TIMEOUT_SEC = 15 // see TIMEXP
 
+jest.setTimeout(60_000)
+
 describe('Timeout Handler', () => {
   const { type, proxyConfig } = config.PROXY_CACHE_CONFIG
   const proxyCache = createProxyCache(type, proxyConfig)
   const proxyClient = new ProxyApiClient()
 
+  const checkKeysExistence = async (keys) => Promise.all(keys.map(key => proxyCache.redisClient.exists(key)))
+
   beforeAll(async () => {
     await proxyCache.connect()
     const redisClient = proxyCache.redisClient
@@ -22,6 +54,11 @@ describe('Timeout Handler', () => {
     }))
   })
 
+  beforeEach(async () => {
+    const history = await proxyClient.deleteHistory()
+    expect(history).toEqual([])
+  })
+
   afterAll(async () => {
     return Promise.all([
       proxyClient.deleteHistory(),
@@ -29,47 +66,65 @@ describe('Timeout Handler', () => {
     ])
   })
 
-  it('test', async () => {
-    let history = await proxyClient.deleteHistory()
-    expect(history).toEqual([])
-
-    // send a couple of keys to redis
-    const partyIds = ['1234567', '7654321']
-    const keys = [
-      `'als:${PAYER_DFSP}:${PARTY_ID_TYPE}:${partyIds[0]}:expiresAt'`,
-      `'als:${PAYER_DFSP}:${PARTY_ID_TYPE}:${partyIds[1]}:expiresAt'`
-    ]
+  it('should pass timeoutInterschemePartiesLookups flow', async () => {
+    const partyIds = [`isp1-${Date.now()}`, `isp2-${Date.now()}`]
     const proxies = [PROXY_NAME]
     const alsReq1 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyIds[0])
     const alsReq2 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyIds[1])
+    const keys = [
+      RedisProxyCache.formatAlsCacheExpiryKey(alsReq1),
+      RedisProxyCache.formatAlsCacheExpiryKey(alsReq2)
+    ]
+    // send a couple of keys to redis
     const results = await Promise.all([
       proxyCache.setSendToProxiesList(alsReq1, proxies, CRON_TIMEOUT_SEC),
       proxyCache.setSendToProxiesList(alsReq2, proxies, CRON_TIMEOUT_SEC)
     ])
-    expect(results.includes(false)).toBe(false)
+    expect(results).toEqual([true, true])
+    expect(await checkKeysExistence(keys)).toEqual([1, 1])
 
     // wait for the timeout handler to process the keys
     await wait(CRON_TIMEOUT_SEC * 1.5)
+    const history = await proxyClient.waitForNHistoryCalls(2)
 
     // check that the keys are no longer in redis
-    const exists = await Promise.all(keys.map(key => proxyCache.redisClient.exists(key)))
-    expect(exists.includes(1)).toBe(false)
-
-    // check that the callbacks are sent and received at the FSP
-    // for test resilience, we will retry the history check a few times
-    const retryMaxCount = 20
-    const retryIntervalSec = 2
-    let retryCount = 0
-
-    while (history.length < 2 && retryCount < retryMaxCount) {
-      await wait(retryIntervalSec)
-      history = await proxyClient.getHistory()
-      retryCount++
-    }
+    expect(await checkKeysExistence(keys)).toEqual([0, 0])
+
     expect(history.length).toBe(2)
     const path0 = history.find(h => h.path.includes(partyIds[0])).path
     const path1 = history.find(h => h.path.includes(partyIds[1])).path
     expect(path0).toBe(`/parties/${PARTY_ID_TYPE}/${partyIds[0]}/error`)
     expect(path1).toBe(`/parties/${PARTY_ID_TYPE}/${partyIds[1]}/error`)
-  }, 60_000)
+  })
+
+  it('should pass timeoutProxyGetPartiesLookups flow', async () => {
+    const partyId1 = `pgp1-${Date.now()}`
+    const partyId2 = `pgp2-${Date.now()}`
+    const alsReq1 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyId1)
+    const alsReq2 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyId2)
+    const keys = [
+      RedisProxyCache.formatProxyGetPartiesExpiryKey(alsReq1, PROXY_NAME),
+      RedisProxyCache.formatProxyGetPartiesExpiryKey(alsReq2, PROXY_NAME)
+    ]
+    // send a couple of keys to redis
+    const results = await Promise.all([
+      proxyCache.setProxyGetPartiesTimeout(alsReq1, PROXY_NAME, CRON_TIMEOUT_SEC),
+      proxyCache.setProxyGetPartiesTimeout(alsReq2, PROXY_NAME, CRON_TIMEOUT_SEC)
+    ])
+    expect(results).toEqual([true, true])
+    expect(await checkKeysExistence(keys)).toEqual([1, 1])
+
+    // wait for the timeout handler to process the keys
+    await wait(CRON_TIMEOUT_SEC * 1.5)
+    const history = await proxyClient.waitForNHistoryCalls(2)
+
+    // check that the keys are no longer in redis
+    expect(await checkKeysExistence(keys)).toEqual([0, 0])
+
+    expect(history.length).toBe(2)
+    const path1 = history.find(h => h.path.includes(partyId1)).path
+    const path2 = history.find(h => h.path.includes(partyId2)).path
+    expect(path1).toBe(`/parties/${PARTY_ID_TYPE}/${partyId1}/error`)
+    expect(path2).toBe(`/parties/${PARTY_ID_TYPE}/${partyId2}/error`)
+  })
 })

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

@@ -26,7 +26,7 @@
  ******/
 
 const { createMockDeps, participantMock } = require('./deps')
-// should be first require to mock external deps
+// ↑ should be first require to mock external deps ↑
 const BasePartiesService = require('#src/domain/parties/services/BasePartiesService')
 const config = require('#src/lib/config')
 const { API_TYPES } = require('#src/constants')

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

@@ -26,7 +26,7 @@
  ******/
 
 const { createMockDeps, createProxyCacheMock, oracleMock, participantMock } = require('./deps')
-// should be first require to mock external deps
+// ↑ should be first require to mock external deps ↑
 const { GetPartiesService } = require('#src/domain/parties/services/index')
 const fixtures = require('#test/fixtures/index')
 

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

@@ -26,6 +26,7 @@
  ******/
 
 const { createMockDeps, oracleMock } = require('./deps')
+// ↑ should be first require to mock external deps ↑
 const { PutPartiesErrorService } = require('#src/domain/parties/services/index')
 const fixtures = require('#test/fixtures/index')
 

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

@@ -0,0 +1,72 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const { createMockDeps, createProxyCacheMock, participantMock } = require('./deps')
+// ↑ should be first require to mock external deps ↑
+const { TimeoutPartiesService } = require('#src/domain/parties/services/index')
+const { API_TYPES } = require('#src/constants')
+const fixtures = require('#test/fixtures/index')
+
+describe('TimeoutPartiesService Tests -->', () => {
+  const { config } = createMockDeps()
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should send error callback to external participant through proxy', async () => {
+    participantMock.validateParticipant = jest.fn().mockResolvedValue(null)
+    const proxy = 'proxyAB'
+    const proxyCache = createProxyCacheMock({
+      lookupProxyByDfspId: jest.fn().mockResolvedValue(proxy)
+    })
+    const deps = createMockDeps({ proxyCache })
+    const cacheKey = fixtures.expiredCacheKeyDto()
+    const service = TimeoutPartiesService.createInstance(deps, cacheKey, 'test')
+
+    await service.handleExpiredKey()
+    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+    expect(participantMock.sendErrorToParticipant.mock.lastCall[0]).toBe(proxy)
+  })
+
+  test('should send error callback in ISO20022 format', async () => {
+    participantMock.validateParticipant = jest.fn().mockResolvedValue({})
+    const deps = {
+      ...createMockDeps(),
+      config: { ...config, API_TYPE: API_TYPES.iso20022 }
+    }
+    const sourceId = 'sourceFsp'
+    const cacheKey = fixtures.expiredCacheKeyDto({ sourceId })
+    const service = TimeoutPartiesService.createInstance(deps, cacheKey, 'test')
+
+    await service.handleExpiredKey()
+    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+    const { Assgnr, Assgne } = participantMock.sendErrorToParticipant.mock.lastCall[2].Assgnmt
+    expect(Assgnr.Agt.FinInstnId.Othr.Id).toBe(config.HUB_NAME)
+    expect(Assgne.Agt.FinInstnId.Othr.Id).toBe(sourceId)
+  })
+})

package/test/unit/domain/timeout/index.test.js

@@ -31,11 +31,13 @@
 
 'use strict'
 
-const Participant = require('../../../../src/models/participantEndpoint/facade')
-const TimeoutDomain = require('../../../../src/domain/timeout')
 const Metrics = require('@mojaloop/central-services-metrics')
+const Participant = require('#src/models/participantEndpoint/facade')
+const TimeoutDomain = require('#src/domain/timeout/index')
+const { mockDeps } = require('#test/util/index')
 
 describe('Timeout Domain', () => {
+  const proxyCache = mockDeps.createProxyCacheMock()
   // Initialize Metrics for testing
   Metrics.getCounter(
     'errorCount',
@@ -56,9 +58,10 @@ describe('Timeout Domain', () => {
   describe('timeoutInterschemePartiesLookups', () => {
     describe('timeoutInterschemePartiesLookups', () => {
       it('should process expired ALS keys', async () => {
-        const mockCache = { processExpiredAlsKeys: jest.fn() }
-        await TimeoutDomain.timeoutInterschemePartiesLookups({ proxyCache: mockCache, batchSize: 10 })
-        expect(mockCache.processExpiredAlsKeys).toHaveBeenCalledWith(TimeoutDomain.sendTimeoutCallback, 10)
+        const batchSize = 10
+        await TimeoutDomain.timeoutInterschemePartiesLookups({ proxyCache, batchSize })
+        expect(proxyCache.processExpiredAlsKeys).toHaveBeenCalledWith(expect.any(Function), batchSize)
+        expect(Participant.sendErrorToParticipant).toHaveBeenCalled()
       })
     })
 
@@ -69,7 +72,7 @@ describe('Timeout Domain', () => {
 
         const cacheKey = `als:${SOURCE_ID}:2:3` // ':expiresAt' part is removed inside proxyCache.processExpiryKey()
 
-        await TimeoutDomain.sendTimeoutCallback(cacheKey)
+        await TimeoutDomain.sendTimeoutCallback(cacheKey, proxyCache)
 
         expect(Participant.validateParticipant).toHaveBeenCalledWith(SOURCE_ID)
         expect(Participant.sendErrorToParticipant).toHaveBeenCalledWith(
@@ -82,7 +85,9 @@ describe('Timeout Domain', () => {
 
       it('should throw error if participant validation fails', async () => {
         Participant.validateParticipant.mockResolvedValue(null)
-        await expect(TimeoutDomain.sendTimeoutCallback('als:sourceId:2:3:expiresAt')).rejects.toThrow()
+        await expect(
+          TimeoutDomain.sendTimeoutCallback('als:sourceId:2:3:expiresAt', proxyCache)
+        ).rejects.toThrow()
       })
     })
   })

package/test/util/apiClients/BasicApiClient.js

@@ -1,16 +1,43 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
 const axiosLib = require('axios')
-const lib = require('../../../src/lib')
-const fixtures = require('../../fixtures')
+const { logger } = require('#src/lib/index')
+const fixtures = require('#test/fixtures/index')
 
 class BasicApiClient {
   constructor ({
     baseURL,
     axios = axiosLib.create({ baseURL }),
-    logger = lib.logger.child(this.constructor.name)
+    log = logger.child({ component: this.constructor.name })
   } = {}) {
     this.baseURL = baseURL
     this.axios = axios
-    this.logger = logger
+    this.log = log
     this.fixtures = fixtures
   }
 
@@ -22,10 +49,10 @@ class BasicApiClient {
         headers,
         data: body
       })
-      this.logger.info('sendRequest is done:', { method, url, body, headers, response: { status, data } })
+      this.log.info(`sendRequest is done [${method} ${url}]:`, { method, url, body, headers, response: { status, data } })
       return { data, status }
     } catch (err) {
-      this.logger.error('error in sendRequest: ', err)
+      this.log.error('error in sendRequest: ', err)
       throw err
     }
   }

package/test/util/apiClients/ProxyApiClient.js

@@ -1,4 +1,32 @@
-const { PROXY_PORT } = require('../../integration/constants')
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const { setTimeout: sleep } = require('node:timers/promises')
+const { PROXY_PORT } = require('#test/integration/constants')
 const BasicApiClient = require('./BasicApiClient')
 
 const baseURL = `http://localhost:${PROXY_PORT}`
@@ -10,6 +38,7 @@ class ProxyApiClient extends BasicApiClient {
 
   async getHistory () {
     const { data } = await this.sendRequest({ url: '/history' })
+    this.log.verbose('getHistory response data: ', { data })
     return data.history
   }
 
@@ -20,6 +49,22 @@ class ProxyApiClient extends BasicApiClient {
     })
     return data.history
   }
+
+  async waitForNHistoryCalls (N, retryMaxCount = 20, retryIntervalSec = 2) {
+    // check that the callbacks are sent and received at the FSP
+    // for test resilience, we will retry the history check a few times
+    let retryCount = 0
+    let history = []
+
+    while (history.length < N && retryCount < retryMaxCount) {
+      await sleep(retryIntervalSec * 1000)
+      history = await this.getHistory()
+      retryCount++
+    }
+    this.log.info('waitForNHistoryCalls is done: ', { history })
+
+    return history
+  }
 }
 
 module.exports = ProxyApiClient

package/test/util/mockDeps.js

@@ -25,10 +25,17 @@
  --------------
  ******/
 
+const fixtures = require('../fixtures')
+
+// eslint-disable-next-line n/no-callback-literal
+const processExpierdKeysFn = async (cb) => cb(fixtures.expiredCacheKeyDto())
+
 const createProxyCacheMock = ({
   addDfspIdToProxyMapping = jest.fn(async () => true),
   isPendingCallback = jest.fn(async () => false),
   lookupProxyByDfspId = jest.fn(async () => null),
+  processExpiredAlsKeys = jest.fn(processExpierdKeysFn),
+  processExpiredProxyGetPartiesKeys = jest.fn(processExpierdKeysFn),
   receivedErrorResponse = jest.fn(async () => false),
   receivedSuccessResponse = jest.fn(async () => true),
   removeDfspIdFromProxyMapping = jest.fn(async () => true),
@@ -39,6 +46,8 @@ const createProxyCacheMock = ({
   addDfspIdToProxyMapping,
   isPendingCallback,
   lookupProxyByDfspId,
+  processExpiredAlsKeys,
+  processExpiredProxyGetPartiesKeys,
   receivedErrorResponse,
   receivedSuccessResponse,
   removeDfspIdFromProxyMapping,

package/src/domain/timeout/dto.js

@@ -1,54 +0,0 @@
-const {
-  Factory: { createFSPIOPError },
-  Enums: { FSPIOPErrorCodes }
-} = require('@mojaloop/central-services-error-handling')
-const {
-  Http: { Headers: { FSPIOP: FSPIOPHeaders } },
-  Events: { Event: { Type: EventType, Action: EventAction } },
-  EndPoints: { FspEndpointTypes },
-  Tags: { QueryTags: QueryTagsEnum }
-} = require('@mojaloop/central-services-shared').Enum
-const { Tracer } = require('@mojaloop/event-sdk')
-const EventFrameworkUtil = require('@mojaloop/central-services-shared').Util.EventFramework
-
-const LibUtil = require('../../lib/util')
-const Config = require('../../lib/config')
-const partiesUtils = require('../parties/partiesUtils')
-
-const timeoutCallbackDto = async ({ destination, partyId, partyType }) => {
-  const headers = {
-    [FSPIOPHeaders.SOURCE]: Config.HUB_NAME,
-    [FSPIOPHeaders.DESTINATION]: destination
-  }
-  const params = {
-    ID: partyId,
-    Type: partyType
-  }
-  const error = createFSPIOPError(FSPIOPErrorCodes.EXPIRED_ERROR)
-
-  const dto = {
-    errorInformation: await partiesUtils.makePutPartiesErrorPayload(Config, error, headers, params),
-    headers,
-    params,
-    endpointType: FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_PUT_ERROR
-  }
-  const span = Tracer.createSpan('timeoutInterschemePartiesLookups', { headers: dto.headers })
-  const spanTags = LibUtil.getSpanTags({ headers: dto.headers }, EventType.PARTY, EventAction.PUT)
-  span.setTags(spanTags)
-  const queryTags = EventFrameworkUtil.Tags.getQueryTags(
-    QueryTagsEnum.serviceName.accountLookupService,
-    QueryTagsEnum.auditType.transactionFlow,
-    QueryTagsEnum.contentType.httpRequest,
-    QueryTagsEnum.operation.timeoutInterschemePartiesLookups,
-    {
-      partyIdType: params.Type,
-      partyIdentifier: params.ID
-    }
-  )
-  span.setTags(queryTags)
-  return { ...dto, span }
-}
-
-module.exports = {
-  timeoutCallbackDto
-}

package/test/unit/domain/timeout/dto.test.js

@@ -1,24 +0,0 @@
-const { API_TYPES } = require('@mojaloop/central-services-shared').Util.Hapi
-const { timeoutCallbackDto } = require('../../../../src/domain/timeout/dto')
-const config = require('../../../../src/lib/config')
-
-const realApiType = config.API_TYPE
-
-describe('timeoutCallbackDto Tests -->', () => {
-  afterAll(() => {
-    config.API_TYPE = realApiType
-  })
-
-  test('should produce ISO payload', async () => {
-    config.API_TYPE = API_TYPES.iso20022
-    const destination = 'D1'
-    const partyId = 'P1'
-    const partyType = 'XXX'
-    const dto = await timeoutCallbackDto({ destination, partyId, partyType })
-    expect(dto.errorInformation).toBeTruthy()
-
-    const { Assgnr, Assgne } = dto.errorInformation.Assgnmt
-    expect(Assgnr.Agt.FinInstnId.Othr.Id).toBe(config.HUB_NAME)
-    expect(Assgne.Agt.FinInstnId.Othr.Id).toBe(destination)
-  })
-})