account-lookup-service 17.4.1-csi-1300.0 → 17.4.1-csi-1300.1

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.4.1-csi-1300.0",
+  "version": "17.4.1-csi-1300.1",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [

package/src/domain/parties/deps.js

@@ -0,0 +1,49 @@
+/*****
+ 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 { proxies } = require('@mojaloop/central-services-shared').Util
+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({
+  cache,
+  proxyCache,
+  childSpan,
+  log,
+  stepState,
+  config,
+  oracle,
+  participant,
+  proxies,
+  partiesUtils
+})
+
+module.exports = {
+  createDeps
+}

package/src/domain/parties/getPartiesByTypeAndID.js

@@ -23,38 +23,11 @@
  --------------
  **********/
 
-const { Enum, Util } = require('@mojaloop/central-services-shared')
-// const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const Metrics = require('@mojaloop/central-services-metrics')
-
-const oracle = require('../../models/oracle/facade')
-const participant = require('../../models/participantEndpoint/facade')
-const config = require('../../lib/config')
 const libUtil = require('../../lib/util')
 const { logger } = require('../../lib')
-// const { createCallbackHeaders } = require('../../lib/headers')
-// const { ERROR_MESSAGES } = require('../../constants')
 const { GetPartiesService } = require('./services')
-const partiesUtils = require('./partiesUtils')
-
-// const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
-// const { Headers, RestMethods } = Enum.Http
-const { Headers } = Enum.Http
-
-// const proxyCacheTtlSec = 40 // todo: make configurable
-
-const createDeps = ({ cache, proxyCache, childSpan, log, stepState }) => Object.freeze({
-  cache,
-  proxyCache,
-  childSpan,
-  log,
-  stepState,
-  config,
-  oracle,
-  participant,
-  proxies: Util.proxies,
-  partiesUtils
-})
+const { createDeps } = require('./deps')
 
 /**
  * @function getPartiesByTypeAndID
@@ -76,261 +49,27 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
     'Get party by Type and Id',
     ['success']
   ).startTimer()
+  const childSpan = span ? span.getChild(component) : undefined
   const log = logger.child({ component, params })
   const stepState = libUtil.initStepState()
-  const childSpan = span ? span.getChild(component) : undefined
 
-  const service = new GetPartiesService(createDeps({
-    cache, proxyCache, childSpan, log, stepState
-  }))
-
-  const proxyEnabled = !!(config.PROXY_CACHE_CONFIG.enabled && proxyCache)
-  const source = headers[Headers.FSPIOP.SOURCE]
-  const proxy = proxyEnabled && headers[Headers.FSPIOP.PROXY]
-  const destination = headers[Headers.FSPIOP.DESTINATION]
-  // see https://github.com/mojaloop/design-authority/issues/79
-  // the requester has specified a destination routing header. We should respect that and forward the request directly to the destination
-  // without consulting any oracles.
-
-  log.info('parties::getPartiesByTypeAndID start', { source, destination, proxy })
-
-  let requester
-  let fspiopError
+  const deps = createDeps({ cache, proxyCache, childSpan, log, stepState })
+  const service = new GetPartiesService(deps)
+  const results = {}
 
   try {
-    requester = await service.validateRequester({ source, proxy })
-
-    if (destination) {
-      await service.forwardRequestToDestination({ destination, headers, params })
-      // await forwardRequestToDestination({
-      //   destination, headers, options, callbackEndpointType, childSpan, proxyEnabled, proxyCache, log, stepState
-      // })
-      histTimerEnd({ success: true })
-      return
-    }
-
-    const response = await service.sendOracleDiscoveryRequest({ headers, params, query })
-
-    if (Array.isArray(response?.data?.partyList) && response.data.partyList.length > 0) {
-      const partyList = service.filterOraclePartyList({ response, params })
-      await service.processOraclePartyList({ partyList, headers, params, destination })
-      // const partyList = filterOraclePartyList({ response, params, log, stepState })
-      // await processOraclePartyList({
-      //   partyList, headers, params, destination, childSpan, proxyEnabled, proxyCache, log, stepState
-      // })
-    } else {
-      log.info('empty partyList form oracle, getting proxies list...', { proxyEnabled, params })
-      const proxyNames = await service.getFilteredProxyList(proxy)
-      // getFilteredProxyList({ config, proxy, proxyEnabled, stepState })
-
-      if (!proxyNames.length) {
-        fspiopError = await service.sendErrorCallback({ requester, headers, params })
-        // sendErrorCallback({
-        //   headers, params, requester, childSpan, stepState
-        // })
-      } else {
-        await service.triggerSendToProxiesFlow({ proxyNames, headers, params, source })
-        // await triggerSendToProxiesFlow({
-        //   proxyNames, headers, params, source, childSpan, proxyCache, log, stepState
-        // })
-      }
-    }
-    log.info('parties::getPartiesByTypeAndID is done')
+    await service.handleRequest({ headers, params, query, results })
+    log.info('getPartiesByTypeAndID is done')
     histTimerEnd({ success: true })
   } catch (err) {
-    fspiopError = await partiesUtils.createErrorHandlerOnSendingCallback(config, log)(err, headers, params, requester)
+    results.fspiopError = await deps.partiesUtils.createErrorHandlerOnSendingCallback(deps.config, log)(err, headers, params, results.requester)
     histTimerEnd({ success: false })
-    if (fspiopError) {
-      libUtil.countFspiopError(fspiopError, { operation: component, step: stepState.step })
+    if (results.fspiopError) {
+      libUtil.countFspiopError(results.fspiopError, { operation: component, step: stepState.step })
     }
   } finally {
-    await libUtil.finishSpanWithError(childSpan, fspiopError)
+    await libUtil.finishSpanWithError(childSpan, results.fspiopError)
   }
 }
 
-// const validateRequester = async ({ source, proxy, proxyCache, stepState }) => {
-//   stepState.inProgress('validateRequester-0')
-//   const log = logger.child({ source, method: 'validateRequester' })
-//   const sourceParticipant = await participant.validateParticipant(source)
-//   if (sourceParticipant) {
-//     log.debug('source is in scheme')
-//     return source
-//   }
-//
-//   if (!proxy) {
-//     const errMessage = ERROR_MESSAGES.sourceFspNotFound
-//     log.warn(errMessage)
-//     throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
-//   }
-//
-//   const proxyParticipant = await participant.validateParticipant(proxy)
-//   if (!proxyParticipant) {
-//     const errMessage = ERROR_MESSAGES.partyProxyNotFound
-//     log.warn(errMessage, { proxy })
-//     throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
-//   }
-//
-//   const isCached = await proxyCache.addDfspIdToProxyMapping(source, proxy)
-//   // think, what if isCached !== true?
-//   log.info('source is added to proxyMapping cache:', { proxy, isCached })
-//   return proxy
-// }
-
-// const forwardRequestToDestination = async ({
-//   destination, headers, options, callbackEndpointType, childSpan, proxyEnabled, proxyCache, log, stepState
-// }) => {
-//   let sendTo = destination
-//   stepState.inProgress('validateDestination-1')
-//
-//   const destParticipantModel = await participant.validateParticipant(destination)
-//   if (!destParticipantModel) {
-//     stepState.inProgress('lookupProxyDestination-2')
-//     const proxyId = proxyEnabled && await proxyCache.lookupProxyByDfspId(destination)
-//
-//     if (!proxyId) {
-//       log.warn('no destination participant, and no dfsp-to-proxy mapping', { destination })
-//       const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-//       throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
-//     }
-//     sendTo = proxyId
-//   }
-//   // all ok, go ahead and forward the request
-//   stepState.inProgress('forwardRequest-3')
-//   await participant.sendRequest(headers, sendTo, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
-//   log.info('discovery getPartiesByTypeAndID request was sent', { sendTo })
-// }
-
-// const filterOraclePartyList = ({ response, params, log, stepState }) => {
-//   // Oracle's API is a standard rest-style end-point Thus a GET /party on the oracle will return all participant-party records. We must filter the results based on the callbackEndpointType to make sure we remove records containing partySubIdOrType when we are in FSPIOP_CALLBACK_URL_PARTIES_GET mode:
-//   stepState.inProgress('filterOraclePartyList-5')
-//   const callbackEndpointType = partiesUtils.getPartyCbType(params.SubId)
-//   let filteredResponsePartyList
-//
-//   switch (callbackEndpointType) {
-//     case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_GET:
-//       filteredResponsePartyList = response.data.partyList.filter(party => party.partySubIdOrType == null) // Filter records that DON'T contain a partySubIdOrType
-//       break
-//     case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_SUB_ID_GET:
-//       filteredResponsePartyList = response.data.partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
-//       break
-//     default:
-//       filteredResponsePartyList = response // Fallback to providing the standard list
-//   }
-//
-//   if (!Array.isArray(filteredResponsePartyList) || !filteredResponsePartyList.length) {
-//     const errMessage = 'Requested FSP/Party not found'
-//     log.warn(errMessage)
-//     throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
-//   }
-//
-//   return filteredResponsePartyList
-// }
-
-// const processOraclePartyList = async ({
-//   partyList, headers, params, destination, childSpan, proxyEnabled, proxyCache, log, stepState
-// }) => {
-//   const callbackEndpointType = partiesUtils.getPartyCbType(params.SubId)
-//   const options = partiesUtils.partiesRequestOptionsDto(params)
-//
-//   let sentCount = 0 // if sentCount === 0 after sending, should we restart the whole process?
-//   const sending = partyList.map(async party => {
-//     const { fspId } = party
-//     const clonedHeaders = { ...headers }
-//     if (!destination) {
-//       clonedHeaders[Headers.FSPIOP.DESTINATION] = fspId
-//     }
-//     stepState.inProgress('validateParticipant-6')
-//     const schemeParticipant = await participant.validateParticipant(fspId)
-//     if (schemeParticipant) {
-//       sentCount++
-//       log.info('participant is in scheme', { fspId })
-//       return participant.sendRequest(clonedHeaders, fspId, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
-//     }
-//
-//     // If the participant is not in the scheme and proxy routing is enabled,
-//     // we should check if there is a proxy for it and send the request to the proxy
-//     if (proxyEnabled) {
-//       stepState.inProgress('lookupProxyByDfspId-7')
-//       const proxyName = await proxyCache.lookupProxyByDfspId(fspId)
-//       if (!proxyName) {
-//         log.warn('no proxyMapping for participant!  TODO: Delete reference in oracle...', { fspId })
-//         // todo: delete reference in oracle
-//       } else {
-//         sentCount++
-//         log.info('participant is NOT in scheme, use proxy name', { fspId, proxyName })
-//         return participant.sendRequest(clonedHeaders, proxyName, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
-//       }
-//     }
-//   })
-//   await Promise.all(sending)
-//   log.verbose('processOraclePartyList is done', { sentCount })
-//   // todo: think what if sentCount === 0 here
-// }
-
-// const getFilteredProxyList = async ({ config, proxy, proxyEnabled, stepState }) => {
-//   stepState.inProgress('getAllProxies-8')
-//   if (!proxyEnabled) return []
-//
-//   const proxyNames = await Util.proxies.getAllProxiesNames(config.SWITCH_ENDPOINT)
-//   return proxyNames.filter(name => name !== proxy)
-// }
-
-// const sendErrorCallback = async ({
-//   headers, params, requester, childSpan, stepState
-// }) => {
-//   stepState.inProgress('sendErrorToParticipant-9')
-//   const callbackHeaders = createCallbackHeaders({
-//     requestHeaders: headers,
-//     partyIdType: params.Type,
-//     partyIdentifier: params.ID,
-//     endpointTemplate: params.SubId
-//       ? FspEndpointTemplates.PARTIES_SUB_ID_PUT_ERROR
-//       : FspEndpointTemplates.PARTIES_PUT_ERROR
-//   })
-//   const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND)
-//
-//   await participant.sendErrorToParticipant(
-//     requester,
-//     partiesUtils.errorPartyCbType(params.SubId),
-//     fspiopError.toApiErrorObject(config.ERROR_HANDLING),
-//     callbackHeaders,
-//     params,
-//     childSpan
-//   )
-//   return fspiopError
-// }
-
-// const triggerSendToProxiesFlow = async ({
-//   proxyNames, headers, params, source, childSpan, proxyCache, log, stepState
-// }) => {
-//   stepState.inProgress('setSendToProxiesList-10')
-//   const alsReq = partiesUtils.alsRequestDto(source, params)
-//   log.info('starting setSendToProxiesList flow: ', { proxyNames, alsReq, proxyCacheTtlSec })
-//
-//   const isCached = await proxyCache.setSendToProxiesList(alsReq, proxyNames, proxyCacheTtlSec)
-//   if (!isCached) {
-//     log.warn('failed to setSendToProxiesList')
-//     throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.failedToCacheSendToProxiesList)
-//   }
-//
-//   const callbackEndpointType = partiesUtils.getPartyCbType(params.SubId)
-//   const options = partiesUtils.partiesRequestOptionsDto(params)
-//   stepState.inProgress('sendingProxyRequests-11')
-//   const sending = proxyNames.map(
-//     proxyName => participant.sendRequest(headers, proxyName, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
-//       .then(({ status, data } = {}) => ({ status, data }))
-//   )
-//   const results = await Promise.allSettled(sending)
-//   const isOk = results.some(result => result.status === 'fulfilled')
-//   // If, at least, one request is sent to proxy, we treat the whole flow as successful.
-//   // Failed requests should be handled by TTL expired/timeout handler
-//   // todo: - think, if we should handle failed requests here (e.g., by calling receivedErrorResponse)
-//   log.info('triggerSendToProxiesFlow is done:', { isOk, results, proxyNames, alsReq })
-//   stepState.inProgress('allSent-12')
-//   if (!isOk) {
-//     log.warn('no successful requests sent to proxies')
-//     throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.proxyConnectionError)
-//   }
-// }
-
 module.exports = getPartiesByTypeAndID

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

@@ -44,8 +44,38 @@ class GetPartiesService {
     this.proxyEnabled = !!(deps.config.PROXY_CACHE_CONFIG?.enabled && deps.proxyCache)
   }
 
-  async handleRequest () {
-    // todo: add logic
+  async handleRequest ({ headers, params, query, results }) {
+    const source = headers[Headers.FSPIOP.SOURCE]
+    const proxy = headers[Headers.FSPIOP.PROXY]
+    const destination = headers[Headers.FSPIOP.DESTINATION]
+    // see https://github.com/mojaloop/design-authority/issues/79
+    // the requester has specified a destination routing header. We should respect that and forward the request directly to the destination
+    // without consulting any oracles.
+    this.log.info('handling getParties request', { source, destination, proxy })
+
+    const requester = await this.validateRequester({ source, proxy })
+    results.requester = requester
+
+    if (destination) {
+      await this.forwardRequestToDestination({ destination, headers, params })
+      return
+    }
+    const response = await this.sendOracleDiscoveryRequest({ headers, params, query })
+
+    if (Array.isArray(response?.data?.partyList) && response.data.partyList.length > 0) {
+      const partyList = this.filterOraclePartyList({ response, params })
+      await this.processOraclePartyList({ partyList, headers, params, destination })
+      return
+    }
+
+    this.log.info('empty partyList form oracle, getting proxyList...', { params })
+    const proxyNames = await this.getFilteredProxyList(proxy)
+
+    if (proxyNames.length) {
+      return this.triggerSendToProxiesFlow({ proxyNames, headers, params, source })
+    }
+
+    results.fspiopError = await this.sendErrorCallback({ requester, headers, params })
   }
 
   async validateRequester ({ source, proxy }) {
@@ -58,7 +88,7 @@ class GetPartiesService {
       return source
     }
 
-    if (!proxy) {
+    if (!this.proxyEnabled || !proxy) {
       const errMessage = ERROR_MESSAGES.sourceFspNotFound
       log.warn(errMessage)
       throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
@@ -173,7 +203,10 @@ class GetPartiesService {
 
   async getFilteredProxyList (proxy) {
     this.#deps.stepState.inProgress('getAllProxies-8')
-    if (!this.proxyEnabled) return []
+    if (!this.proxyEnabled) {
+      this.log.warn('proxyCache is not enabled')
+      return []
+    }
 
     const proxyNames = await this.#deps.proxies.getAllProxiesNames(this.#deps.config.SWITCH_ENDPOINT)
     this.log.debug('getAllProxiesNames is done', { proxyNames })