account-lookup-service 17.7.0-snapshot.4 → 17.7.0

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,11 +1,10 @@
 {
   "name": "account-lookup-service",
   "description": "Account Lookup Service is used to validate Party and Participant lookups.",
-  "version": "17.7.0-snapshot.4",
+  "version": "17.7.0",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
-    "Eugen Klymniuk <eugen.klymniuk@infitx.com>",
     "Rajiv Mothilal <rajiv.mothilal@modusbox.com>",
     "Matt Kingston <matt.kingston@modusbox.com>",
     "Lewis Daly <lewisd@crosslaketech.com>",
@@ -45,8 +44,10 @@
     "start:api": "node src/index.js server --api",
     "start:admin": "node src/index.js server --admin",
     "start:handlers": "node src/handlers/index.js handlers --timeout",
-    "lint": "standard",
-    "lint:fix": "standard --fix",
+    "standard": "standard",
+    "standard:fix": "standard --fix",
+    "lint": "npm run standard",
+    "lint:fix": "npm run standard:fix",
     "dev": "nodemon src/index.js server",
     "test": "npm run test:unit",
     "test:unit": "NODE_OPTIONS='--experimental-vm-modules --max-old-space-size=8192' jest --runInBand",
@@ -189,9 +190,5 @@
     "scripts": {
       "postchangelog": "replace '\\[mojaloop/#(\\d+)\\]\\(https://github.com/mojaloop/(.*)/issues/(\\d+)\\)' '[mojaloop/#$1](https://github.com/mojaloop/project/issues/$1)' CHANGELOG.md"
     }
-  },
-  "imports": {
-    "#src/*": "./src/*.js",
-    "#test/*": "./test/*.js"
   }
 }

package/src/constants.js

@@ -1,40 +1,9 @@
-/*****
- 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 { API_TYPES } = require('@mojaloop/central-services-shared').Util.Hapi
-
 const ERROR_MESSAGES = Object.freeze({
-  emptyFilteredPartyList: 'Empty oracle partyList, filtered based on callbackEndpointType',
-  failedToCacheSendToProxiesList: 'Failed to cache sendToProxiesList',
-  noDiscoveryRequestsForwarded: 'No discovery requests forwarded to participants',
   sourceFspNotFound: 'Requester FSP not found',
   partyDestinationFspNotFound: 'Destination FSP not found',
   partyProxyNotFound: 'Proxy not found',
-  proxyConnectionError: 'Proxy connection error - no successful requests sent to proxies'
+  proxyConnectionError: 'Proxy connection error',
+  failedToCacheSendToProxiesList: 'Failed to cache sendToProxiesList'
 })
 
 const HANDLER_TYPES = Object.freeze({
@@ -42,7 +11,6 @@ const HANDLER_TYPES = Object.freeze({
 })
 
 module.exports = {
-  API_TYPES,
   ERROR_MESSAGES,
   HANDLER_TYPES
 }

package/src/domain/parties/deps.js

@@ -26,18 +26,17 @@
  ******/
 
 const { proxies } = require('@mojaloop/central-services-shared').Util
-const { logger } = require('../../lib')
-const config = require('../../lib/config')
 const oracle = require('../../models/oracle/facade')
 const participant = require('../../models/participantEndpoint/facade')
+const config = require('../../lib/config')
 const partiesUtils = require('./partiesUtils')
 
-/** @returns {PartiesDeps} */
-const createDeps = ({ cache, proxyCache, childSpan, log = logger }) => Object.freeze({
+const createDeps = ({ cache, proxyCache, childSpan, log, stepState }) => Object.freeze({
   cache,
   proxyCache,
   childSpan,
   log,
+  stepState,
   config,
   oracle,
   participant,

package/src/domain/parties/getPartiesByTypeAndID.js

@@ -50,22 +50,26 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
     ['success']
   ).startTimer()
   const childSpan = span ? span.getChild(component) : undefined
-  const deps = createDeps({ cache, proxyCache, childSpan })
-  const service = new GetPartiesService(deps, { headers, params, query })
-  let fspiopError
+  const log = logger.child({ component, params })
+  const stepState = libUtil.initStepState()
+
+  const deps = createDeps({ cache, proxyCache, childSpan, log, stepState })
+  const service = new GetPartiesService(deps)
+  const results = {}
 
   try {
-    await service.handleRequest()
-    logger.info('getPartiesByTypeAndID is done')
+    await service.handleRequest({ headers, params, query, results })
+    log.info('getPartiesByTypeAndID is done')
     histTimerEnd({ success: true })
   } catch (error) {
-    fspiopError = await service.handleError(error)
+    const { requester } = results
+    results.fspiopError = await service.handleError({ error, requester, headers, params })
     histTimerEnd({ success: false })
-    if (fspiopError) {
-      libUtil.countFspiopError(fspiopError, { operation: component, step: service.currenStep })
+    if (results.fspiopError) {
+      libUtil.countFspiopError(results.fspiopError, { operation: component, step: stepState.step })
     }
   } finally {
-    await libUtil.finishSpanWithError(childSpan, fspiopError)
+    await libUtil.finishSpanWithError(childSpan, results.fspiopError)
   }
 }
 

package/src/domain/parties/partiesUtils.js

@@ -25,9 +25,13 @@
  --------------
  ******/
 
-const { Enum } = require('@mojaloop/central-services-shared')
+const { Enum, Util: { Hapi } } = require('@mojaloop/central-services-shared')
+const { MojaloopApiErrorCodes } = require('@mojaloop/sdk-standard-components').Errors
+// todo: check why do we need sdk-standard-components deps here !!!
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+
+const participant = require('../../models/participantEndpoint/facade')
 const { TransformFacades } = require('../../lib')
-const { API_TYPES } = require('../../constants')
 
 const { FspEndpointTypes } = Enum.EndPoints
 const { Headers } = Enum.Http
@@ -46,7 +50,7 @@ const errorPartyCbType = (partySubId) => partySubId
 
 const makePutPartiesErrorPayload = async (config, fspiopError, headers, params) => {
   const body = fspiopError.toApiErrorObject(config.ERROR_HANDLING)
-  return config.API_TYPE === API_TYPES.iso20022
+  return config.API_TYPE === Hapi.API_TYPES.iso20022
     ? (await TransformFacades.FSPIOP.parties.putError({ body, headers, params })).body
     : body
 }
@@ -77,12 +81,38 @@ const swapSourceDestinationHeaders = (headers) => {
   }
 }
 
+// todo: check if we need this function
+const createErrorHandlerOnSendingCallback = (config, logger) => async (err, headers, params, requester) => {
+  try {
+    logger.error('error in sending parties callback: ', err)
+    const sendTo = requester || headers[Headers.FSPIOP.SOURCE]
+    const errorCallbackEndpointType = errorPartyCbType(params.SubId)
+    const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
+    const errInfo = await makePutPartiesErrorPayload(config, fspiopError, headers, params)
+
+    await participant.sendErrorToParticipant(sendTo, errorCallbackEndpointType, errInfo, headers, params)
+
+    logger.info('handleErrorOnSendingCallback in done', { sendTo, params, errInfo })
+    return fspiopError
+  } catch (exc) {
+    // We can't do anything else here- we _must_ handle all errors _within_ this function because
+    // we've already sent a sync response- we cannot throw.
+    logger.error('failed to handleErrorOnSendingCallback. No further processing! ', exc)
+  }
+}
+
+function isNotValidPayeeCase (payload) {
+  return payload?.errorInformation?.errorCode === MojaloopApiErrorCodes.PAYEE_IDENTIFIER_NOT_VALID.code
+}
+
 module.exports = {
   getPartyCbType,
   putPartyCbType,
   errorPartyCbType,
   makePutPartiesErrorPayload,
+  createErrorHandlerOnSendingCallback,
   alsRequestDto,
   partiesRequestOptionsDto,
-  swapSourceDestinationHeaders
+  swapSourceDestinationHeaders,
+  isNotValidPayeeCase
 }

package/src/domain/parties/putParties.js

@@ -29,6 +29,7 @@
 
 'use strict'
 
+const { Headers } = require('@mojaloop/central-services-shared').Enum.Http
 const Metrics = require('@mojaloop/central-services-metrics')
 const libUtil = require('../../lib/util')
 const { logger } = require('../../lib')
@@ -36,7 +37,9 @@ const { createDeps } = require('./deps')
 const services = require('./services')
 
 /**
- * Sends a callback to inform participant of successful lookup
+ * @function putPartiesByTypeAndID
+ *
+ * @description This sends a callback to inform participant of successful lookup
  *
  * @param {object} headers - incoming http request headers
  * @param {object} params - uri parameters of the http request
@@ -55,25 +58,45 @@ const putPartiesByTypeAndID = async (headers, params, method, payload, dataUri,
     ['success']
   ).startTimer()
   // const childSpan = span ? span.getChild(component) : undefined
-  const deps = createDeps({ cache, proxyCache })
-  const service = new services.PutPartiesService(deps, { headers, params, payload, dataUri })
-  let fspiopError
+  const log = logger.child({ component, params })
+  const stepState = libUtil.initStepState()
+
+  const deps = createDeps({ cache, proxyCache, log, stepState })
+  const service = new services.PutPartiesService(deps)
+  const results = {}
+
+  const source = headers[Headers.FSPIOP.SOURCE]
+  const destination = headers[Headers.FSPIOP.DESTINATION]
+  const proxy = headers[Headers.FSPIOP.PROXY]
+  log.info('putPartiesByTypeAndID start', { source, destination, proxy })
 
   try {
-    await service.handleRequest()
-    logger.info('putPartiesByTypeAndID is done')
+    await service.validateSourceParticipant({ source, proxy })
+
+    if (proxy) {
+      await service.checkProxySuccessResponse({ destination, source, headers, params })
+    }
+
+    const sendTo = await service.identifyDestinationForSuccessCallback(destination)
+    results.requester = sendTo
+    await service.sendSuccessCallback({ sendTo, headers, params, dataUri })
+
+    log.info('putPartiesByTypeAndID callback was sent', { sendTo })
     histTimerEnd({ success: true })
   } catch (error) {
-    fspiopError = await service.handleError(error)
-    if (fspiopError) {
-      libUtil.countFspiopError(fspiopError, { operation: component, step: service.currenStep })
+    const { requester } = results
+    results.fspiopError = await service.handleError({ error, requester, headers, params })
+    if (results.fspiopError) {
+      libUtil.countFspiopError(results.fspiopError, { operation: component, step: stepState.step })
     }
     histTimerEnd({ success: false })
   }
 }
 
 /**
- * Sends error callback to inform participant of failed lookup
+ * @function putPartiesErrorByTypeAndID
+ *
+ * @description This populates the cache of endpoints
  *
  * @param {object} headers - incoming http request headers
  * @param {object} params - uri parameters of the http request
@@ -91,31 +114,53 @@ const putPartiesErrorByTypeAndID = async (headers, params, payload, dataUri, spa
     ['success']
   ).startTimer()
   const childSpan = span ? span.getChild(component) : undefined
-  const deps = createDeps({ cache, proxyCache, childSpan })
-  const inputs = { headers, params, payload, dataUri }
-  const service = new services.PutPartiesErrorService(deps, inputs)
-  let fspiopError
+  const log = logger.child({ component, params })
+  const stepState = libUtil.initStepState()
+
+  const deps = createDeps({ cache, proxyCache, childSpan, log, stepState })
+  const service = new services.PutPartiesErrorService(deps)
+  const results = {}
+
+  const destination = headers[Headers.FSPIOP.DESTINATION]
+  const proxy = headers[Headers.FSPIOP.PROXY]
+  const proxyEnabled = !!(deps.config.PROXY_CACHE_CONFIG.enabled && proxyCache)
+  log.info('putPartiesErrorByTypeAndID start', { destination, proxy, proxyEnabled })
 
   try {
-    const needDiscovery = await service.handleRequest()
-    if (needDiscovery) {
-      const getPartiesService = new services.GetPartiesService(deps, inputs)
-      await getPartiesService.triggerInterSchemeDiscoveryFlow(
-        services.GetPartiesService.headersWithoutDestination(headers)
-      )
-      // think, if we need to start the whole processing with getPartiesService.handleRequest() ?
+    if (proxyEnabled && proxy) {
+      const notValid = await service.checkPayee({ headers, params, payload, proxy })
+      if (notValid) {
+        const getPartiesService = new services.GetPartiesService(deps)
+        // todo: think, if we need to remove destination header before starting new discovery
+        await getPartiesService.handleRequest({ headers, params, results })
+        log.info('putPartiesErrorByTypeAndID triggered new discovery flow')
+        histTimerEnd({ success: true })
+        return
+      }
+
+      const isLast = await service.checkLastProxyCallback({ destination, proxy, params })
+      if (!isLast) {
+        log.info('putPartiesErrorByTypeAndID proxy callback was processed', { proxy })
+        histTimerEnd({ success: true })
+        return
+      }
     }
 
-    logger.info('putPartiesErrorByTypeAndID is done')
+    const sendTo = await service.identifyDestinationForErrorCallback(destination)
+    results.requester = sendTo
+    await service.sendErrorCallbackToParticipant({ sendTo, headers, params, dataUri })
+
+    log.info('putPartiesErrorByTypeAndID callback was sent', { sendTo })
     histTimerEnd({ success: true })
   } catch (error) {
-    fspiopError = await service.handleError(error)
-    if (fspiopError) {
-      libUtil.countFspiopError(fspiopError, { operation: component, step: service.currenStep })
+    const { requester } = results
+    results.fspiopError = await service.handleError({ error, requester, headers, params })
+    if (results.fspiopError) {
+      libUtil.countFspiopError(results.fspiopError, { operation: component, step: stepState.step })
     }
     histTimerEnd({ success: false })
   } finally {
-    await libUtil.finishSpanWithError(childSpan, fspiopError)
+    await libUtil.finishSpanWithError(childSpan, results.fspiopError)
   }
 }
 

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

@@ -26,93 +26,33 @@
  ******/
 
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
-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 { Enum } = require('@mojaloop/central-services-shared')
 
 const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
 const { Headers, RestMethods } = Enum.Http
 
-/**
- * @typedef {Object} PartiesDeps
- * @property {Object} cache
- * @property {Object} proxyCache
- * @property {Object} log
- * @property {Object} config
- * @property {Object} oracle
- * @property {Object} participant
- * @property {Proxies} proxies
- * @property {Object} partiesUtils
- * @property {Object} [childSpan]
- */
-
-/**
- * Input parameters from party lookup request
- *
- * @typedef {Object} PartiesInputs
- * @property {Object} headers - incoming http request headers.
- * @property {Object} params - uri parameters of the http request.
- * @property {Object} [payload] - payload of the request being sent out.
- * @property {Object} [query] - uri query parameters of the http request
- * @property {string} [dataUri] - encoded payload of the request being sent out.
- */
-
-/**
- * Any calculated values we get during request processing
- *
- * @typedef {Object} PartiesModelState
- * @property {string} destination - The destination DFSP ID from headers
- * @property {string} source - The source DFSP ID from headers
- * @property {string} [proxy] - The proxy DFSP ID from headers, if present
- * @property {string} requester - The entity initiating the request (either a DFSP in scheme or a proxy)
- * @property {boolean} proxyEnabled - Indicates whether proxy functionality is enabled in the current configuration
- * @property {StepState} stepState - Processing steps state
- */
-
 class BasePartiesService {
-  #deps // see PartiesDeps
-  #inputs // see PartiesInputs
-  #state // see PartiesModelState
-
-  /**
-   * @param {PartiesDeps} deps - The dependencies required by the class instance.
-   * @param {PartiesInputs} inputs - The input parameters from incoming http request.
-   * @return {void}
-   */
-  constructor (deps, inputs) {
-    this.#deps = Object.freeze(deps)
-    this.#inputs = Object.freeze(inputs)
-    this.#state = this.#initiateState()
-    this.log = this.deps.log.child({
-      component: this.constructor.name,
-      params: this.inputs.params
-    })
+  constructor (deps) {
+    this.deps = deps
+    this.log = this.deps.log.child({ component: this.constructor.name })
+    this.proxyEnabled = !!(deps.config.PROXY_CACHE_CONFIG?.enabled && deps.proxyCache)
   }
 
-  /** @returns {PartiesDeps} */
-  get deps () { return this.#deps }
-
-  /** @returns {PartiesInputs} */
-  get inputs () { return this.#inputs }
+  // async handleRequest () {
+  //   throw new Error('handleRequest must be implemented by subclass')
+  // }
 
-  /** @returns {PartiesModelState} */
-  get state () { return this.#state }
-
-  async handleError (error) {
-    const { headers, params } = this.inputs
+  async handleError ({ error, requester, headers, params }) {
     const log = this.log.child({ method: 'handleError' })
     try {
       log.error('error in processing parties request: ', error)
+      const sendTo = requester || headers[Headers.FSPIOP.SOURCE]
       const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(error)
       const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, fspiopError, headers, params)
 
-      await this.sendErrorCallback({
-        errorInfo,
-        headers: BasePartiesService.createErrorCallbackHeaders(headers, params),
-        params
-      })
-      log.info('handleError in done')
+      await this.sendErrorCallback({ sendTo, errorInfo, headers, params })
+      log.info('handleError in done', { sendTo, errorInfo })
       return fspiopError
     } catch (exc) {
       // We can't do anything else here- we _must_ handle all errors _within_ this function because
@@ -122,88 +62,26 @@ class BasePartiesService {
   }
 
   async validateParticipant (participantId) {
-    this.stepInProgress('validateParticipant')
     return this.deps.participant.validateParticipant(participantId)
   }
 
-  async sendErrorCallback ({ errorInfo, headers, params }) {
-    this.stepInProgress('sendErrorCallback')
-    const sendTo = this.state.requester || this.state.source
+  async sendErrorCallback ({ sendTo, errorInfo, headers, params, payload = undefined }) {
     const endpointType = this.deps.partiesUtils.errorPartyCbType(params.SubId)
-
     await this.deps.participant.sendErrorToParticipant(
-      sendTo, endpointType, errorInfo, headers, params, undefined, this.deps.childSpan
+      sendTo, endpointType, errorInfo, headers, params, payload, this.deps.childSpan
     )
-    this.log.info('sendErrorCallback is done', { sendTo, errorInfo })
+    this.log.verbose('sendErrorCallback is done', { sendTo, errorInfo })
   }
 
   async sendDeleteOracleRequest (headers, params) {
-    this.stepInProgress('sendDeleteOracleRequest')
     return this.deps.oracle.oracleRequest(headers, RestMethods.DELETE, params, null, null, this.deps.cache)
   }
 
-  async removeProxyGetPartiesTimeoutCache (alsReq) {
-    const isRemoved = await this.deps.proxyCache.removeProxyGetPartiesTimeout(alsReq, this.state.proxy)
-    this.log.debug('removeProxyGetPartiesTimeoutCache is done', { isRemoved, alsReq })
-    return isRemoved
-  }
-
-  createFspiopIdNotFoundError (errMessage, log = this.log) {
-    log.warn(errMessage)
-    return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
-  }
-
-  stepInProgress (stepName) {
-    this.log.debug('step is in progress', { stepName })
-    this.state.stepState?.inProgress(stepName)
-  }
-
-  get currenStep () {
-    return this.state.stepState?.step
-  }
-
-  /** @returns {PartiesModelState} */
-  #initiateState () {
-    const { headers } = this.inputs
-    return {
-      destination: headers[Headers.FSPIOP.DESTINATION],
-      source: headers[Headers.FSPIOP.SOURCE],
-      proxy: headers[Headers.FSPIOP.PROXY],
-      requester: '', // dfsp in scheme  OR  proxy
-      proxyEnabled: !!(this.deps.config.PROXY_CACHE_CONFIG?.enabled && this.deps.proxyCache),
-      stepState: initStepState()
-    }
-  }
-
   static decodeDataUriPayload (dataUri) {
     const decoded = decodePayload(dataUri, { asParsed: false })
     return decoded.body.toString()
   }
 
-  static headersWithoutDestination (headers) {
-    const { [Headers.FSPIOP.DESTINATION]: _, ...restHeaders } = headers || {}
-    return restHeaders
-  }
-
-  static overrideDestinationHeader (headers, destination) {
-    const { [Headers.FSPIOP.DESTINATION]: _, ...restHeaders } = headers || {}
-    return {
-      ...restHeaders,
-      ...(destination && { [Headers.FSPIOP.DESTINATION]: destination })
-    }
-  }
-
-  static createErrorCallbackHeaders (headers, params) {
-    return createCallbackHeaders({
-      requestHeaders: headers,
-      partyIdType: params.Type,
-      partyIdentifier: params.ID,
-      endpointTemplate: params.SubId
-        ? FspEndpointTemplates.PARTIES_SUB_ID_PUT_ERROR
-        : FspEndpointTemplates.PARTIES_PUT_ERROR
-    })
-  }
-
   static enums () {
     return {
       FspEndpointTypes,