account-lookup-service 17.6.0 → 17.7.0-snapshot.0

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.6.0",
+  "version": "17.7.0-snapshot.0",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
@@ -44,10 +44,8 @@
     "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",
-    "standard": "standard",
-    "standard:fix": "standard --fix",
-    "lint": "npm run standard",
-    "lint:fix": "npm run standard:fix",
+    "lint": "standard",
+    "lint:fix": "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",
@@ -95,13 +93,13 @@
     "@mojaloop/central-services-health": "15.0.4",
     "@mojaloop/central-services-logger": "11.7.0",
     "@mojaloop/central-services-metrics": "12.5.0",
-    "@mojaloop/central-services-shared": "18.23.0",
+    "@mojaloop/central-services-shared": "18.23.1-snapshot.0",
     "@mojaloop/central-services-stream": "11.5.1",
     "@mojaloop/database-lib": "11.1.4",
     "@mojaloop/event-sdk": "14.3.2",
-    "@mojaloop/inter-scheme-proxy-cache-lib": "2.3.7",
+    "@mojaloop/inter-scheme-proxy-cache-lib": "2.4.0-snapshot.0",
     "@mojaloop/ml-schema-transformer-lib": "2.5.8",
-    "@mojaloop/sdk-standard-components": "19.10.3",
+    "@mojaloop/sdk-standard-components": "19.11.0",
     "@now-ims/hapi-now-auth": "2.1.0",
     "ajv": "8.17.1",
     "ajv-keywords": "5.1.0",
@@ -163,7 +161,7 @@
   "devDependencies": {
     "@types/jest": "29.5.14",
     "audit-ci": "^7.1.0",
-    "axios": "1.8.3",
+    "axios": "1.8.4",
     "axios-retry": "^4.5.0",
     "docdash": "2.0.2",
     "dotenv": "^16.4.7",
@@ -178,7 +176,7 @@
     "pre-commit": "1.2.2",
     "proxyquire": "2.1.3",
     "replace": "^1.2.2",
-    "sinon": "19.0.2",
+    "sinon": "19.0.4",
     "standard": "17.1.2",
     "standard-version": "^9.5.0",
     "swagmock": "1.0.0"
@@ -190,5 +188,9 @@
     "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,9 +1,38 @@
+/*****
+ 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 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',
-  failedToCacheSendToProxiesList: 'Failed to cache sendToProxiesList'
+  proxyConnectionError: 'Proxy connection error - no successful requests sent to proxies'
 })
 
 const HANDLER_TYPES = Object.freeze({

package/src/domain/parties/deps.js

@@ -26,17 +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')
 
-const createDeps = ({ cache, proxyCache, childSpan, log, stepState }) => Object.freeze({
+const createDeps = ({ cache, proxyCache, childSpan, log = logger }) => Object.freeze({
   cache,
   proxyCache,
   childSpan,
   log,
-  stepState,
   config,
   oracle,
   participant,

package/src/domain/parties/getPartiesByTypeAndID.js

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

package/src/domain/parties/putParties.js

@@ -29,7 +29,6 @@
 
 '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')
@@ -37,9 +36,7 @@ const { createDeps } = require('./deps')
 const services = require('./services')
 
 /**
- * @function putPartiesByTypeAndID
- *
- * @description This sends a callback to inform participant of successful lookup
+ * 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
@@ -58,45 +55,25 @@ const putPartiesByTypeAndID = async (headers, params, method, payload, dataUri,
     ['success']
   ).startTimer()
   // const childSpan = span ? span.getChild(component) : undefined
-  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 })
+  const deps = createDeps({ cache, proxyCache })
+  const service = new services.PutPartiesService(deps, { headers, params, payload, dataUri })
+  let fspiopError
 
   try {
-    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 })
+    await service.handleRequest()
+    logger.info('putPartiesByTypeAndID is done')
     histTimerEnd({ success: true })
   } catch (error) {
-    const { requester } = results
-    results.fspiopError = await service.handleError({ error, requester, headers, params })
-    if (results.fspiopError) {
-      libUtil.countFspiopError(results.fspiopError, { operation: component, step: stepState.step })
+    fspiopError = await service.handleError(error)
+    if (fspiopError) {
+      libUtil.countFspiopError(fspiopError, { operation: component, step: service.currenStep })
     }
     histTimerEnd({ success: false })
   }
 }
 
 /**
- * @function putPartiesErrorByTypeAndID
- *
- * @description This populates the cache of endpoints
+ * Sends error callback to inform participant of failed lookup
  *
  * @param {object} headers - incoming http request headers
  * @param {object} params - uri parameters of the http request
@@ -114,53 +91,31 @@ const putPartiesErrorByTypeAndID = async (headers, params, payload, dataUri, spa
     ['success']
   ).startTimer()
   const childSpan = span ? span.getChild(component) : undefined
-  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 })
+  const deps = createDeps({ cache, proxyCache, childSpan })
+  const inputs = { headers, params, payload, dataUri }
+  const service = new services.PutPartiesErrorService(deps, inputs)
+  let fspiopError
 
   try {
-    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
-      }
+    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() ?
     }
 
-    const sendTo = await service.identifyDestinationForErrorCallback(destination)
-    results.requester = sendTo
-    await service.sendErrorCallbackToParticipant({ sendTo, headers, params, dataUri })
-
-    log.info('putPartiesErrorByTypeAndID callback was sent', { sendTo })
+    logger.info('putPartiesErrorByTypeAndID is done')
     histTimerEnd({ success: true })
   } catch (error) {
-    const { requester } = results
-    results.fspiopError = await service.handleError({ error, requester, headers, params })
-    if (results.fspiopError) {
-      libUtil.countFspiopError(results.fspiopError, { operation: component, step: stepState.step })
+    fspiopError = await service.handleError(error)
+    if (fspiopError) {
+      libUtil.countFspiopError(fspiopError, { operation: component, step: service.currenStep })
     }
     histTimerEnd({ success: false })
   } finally {
-    await libUtil.finishSpanWithError(childSpan, results.fspiopError)
+    await libUtil.finishSpanWithError(childSpan, fspiopError)
   }
 }
 

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

@@ -26,33 +26,61 @@
  ******/
 
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
-const { decodePayload } = require('@mojaloop/central-services-shared').Util.StreamingProtocol
 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 { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
 const { Headers, RestMethods } = Enum.Http
 
+/**
+ * @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.
+ */
+
 class BasePartiesService {
-  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)
+  #deps
+  #inputs // see PartiesInputs
+  #state // any calculated values we get during request processing
+
+  /**
+   * @param {Object} 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
+    })
   }
 
-  // async handleRequest () {
-  //   throw new Error('handleRequest must be implemented by subclass')
-  // }
+  get deps () { return this.#deps }
+  get inputs () { return this.#inputs }
+  get state () { return this.#state }
 
-  async handleError ({ error, requester, headers, params }) {
+  async handleError (error) {
+    const { headers, params } = this.inputs
     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({ sendTo, errorInfo, headers, params })
-      log.info('handleError in done', { sendTo, errorInfo })
+      await this.sendErrorCallback({
+        errorInfo,
+        headers: BasePartiesService.createErrorCallbackHeaders(headers, params),
+        params
+      })
+      log.info('handleError in done')
       return fspiopError
     } catch (exc) {
       // We can't do anything else here- we _must_ handle all errors _within_ this function because
@@ -62,26 +90,80 @@ class BasePartiesService {
   }
 
   async validateParticipant (participantId) {
+    this.stepInProgress('validateParticipant')
     return this.deps.participant.validateParticipant(participantId)
   }
 
-  async sendErrorCallback ({ sendTo, errorInfo, headers, params, payload = undefined }) {
+  async sendErrorCallback ({ errorInfo, headers, params }) {
+    this.stepInProgress('sendErrorCallback')
+    const sendTo = this.state.requester || this.state.source
     const endpointType = this.deps.partiesUtils.errorPartyCbType(params.SubId)
+
     await this.deps.participant.sendErrorToParticipant(
-      sendTo, endpointType, errorInfo, headers, params, payload, this.deps.childSpan
+      sendTo, endpointType, errorInfo, headers, params, undefined, this.deps.childSpan
     )
-    this.log.verbose('sendErrorCallback is done', { sendTo, errorInfo })
+    this.log.info('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)
   }
 
+  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
+  }
+
+  #initiateState () {
+    const { headers } = this.inputs
+    return {
+      destination: headers[Headers.FSPIOP.DESTINATION],
+      source: headers[Headers.FSPIOP.SOURCE],
+      proxy: headers[Headers.FSPIOP.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,