@mojaloop/central-ledger 9.2.2 → 15.1.3-snapshot.2

package/src/models/participant/facade.js

@@ -31,38 +31,84 @@
 const Db = require('../../lib/db')
 const Time = require('@mojaloop/central-services-shared').Util.Time
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const Metrics = require('@mojaloop/central-services-metrics')
+const Cache = require('../../lib/cache')
+const ParticipantModelCached = require('../../models/participant/participantCached')
 const ParticipantCurrencyModelCached = require('../../models/participant/participantCurrencyCached')
+const ParticipantLimitCached = require('../../models/participant/participantLimitCached')
+const Config = require('../../lib/config')
+const SettlementModelModel = require('../settlement/settlementModel')
+const { Enum } = require('@mojaloop/central-services-shared')
 
 const getByNameAndCurrency = async (name, currencyId, ledgerAccountTypeId, isCurrencyActive) => {
+  const histTimerParticipantGetByNameAndCurrencyEnd = Metrics.getHistogram(
+    'model_participant',
+    'facade_getByNameAndCurrency - Metrics for participant model',
+    ['success', 'queryName']
+  ).startTimer()
+
   try {
-    return await Db.participant.query(async (builder) => {
-      let b = builder
-        .where({ 'participant.name': name })
-        .andWhere({ 'pc.currencyId': currencyId })
-        .andWhere({ 'pc.ledgerAccountTypeId': ledgerAccountTypeId })
-        .innerJoin('participantCurrency AS pc', 'pc.participantId', 'participant.participantId')
-        .select(
-          'participant.*',
-          'pc.participantCurrencyId',
-          'pc.currencyId',
-          'pc.isActive AS currencyIsActive'
-        )
-        .first()
+    let participant
+    if (Cache.isCacheEnabled()) {
+      /* Cached version - fetch data from Models (which we trust are cached) */
+      /* find paricipant id by name */
+      participant = await ParticipantModelCached.getByName(name)
+      if (participant) {
+        /* use the paricipant id and incoming params to prepare the filter */
+        const searchFilter = {
+          participantId: participant.participantId,
+          currencyId,
+          ledgerAccountTypeId
+        }
+        if (isCurrencyActive !== undefined) {
+          searchFilter.isActive = isCurrencyActive
+        }
+
+        /* find the participantCurrency by prepared filter */
+        const participantCurrency = await ParticipantCurrencyModelCached.findOneByParams(searchFilter)
 
-      if (isCurrencyActive !== undefined) {
-        b = b.andWhere({ 'pc.isActive': isCurrencyActive })
+        if (participantCurrency) {
+          /* mix requested data from participantCurrency */
+          participant.participantCurrencyId = participantCurrency.participantCurrencyId
+          participant.currencyId = participantCurrency.currencyId
+          participant.currencyIsActive = participantCurrency.isActive
+        }
       }
+    } else {
+      /* Non-cached version - direct call to DB */
+      participant = await Db.from('participant').query(async (builder) => {
+        let b = builder
+          .where({ 'participant.name': name })
+          .andWhere({ 'pc.currencyId': currencyId })
+          .andWhere({ 'pc.ledgerAccountTypeId': ledgerAccountTypeId })
+          .innerJoin('participantCurrency AS pc', 'pc.participantId', 'participant.participantId')
+          .select(
+            'participant.*',
+            'pc.participantCurrencyId',
+            'pc.currencyId',
+            'pc.isActive AS currencyIsActive'
+          )
+          .first()
 
-      return b
-    })
+        if (isCurrencyActive !== undefined) {
+          b = b.andWhere({ 'pc.isActive': isCurrencyActive })
+        }
+        return b
+      })
+    }
+
+    histTimerParticipantGetByNameAndCurrencyEnd({ success: true, queryName: 'facade_getByNameAndCurrency' })
+
+    return participant
   } catch (err) {
+    histTimerParticipantGetByNameAndCurrencyEnd({ success: false, queryName: 'facade_getByNameAndCurrency' })
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const getParticipantLimitByParticipantIdAndCurrencyId = async (participantId, currencyId, ledgerAccountTypeId) => {
   try {
-    return await Db.participant.query(async (builder) => {
+    return await Db.from('participant').query(async (builder) => {
       return builder
         .where({
           'participant.participantId': participantId,
@@ -96,7 +142,7 @@ const getParticipantLimitByParticipantIdAndCurrencyId = async (participantId, cu
 
 const getLimitsForAllParticipants = async (currencyId, type, ledgerAccountTypeId) => {
   try {
-    return Db.participant.query(async (builder) => {
+    return Db.from('participant').query(async (builder) => {
       return builder
         .where({
           'pc.ledgerAccountTypeId': ledgerAccountTypeId,
@@ -147,7 +193,7 @@ const getLimitsForAllParticipants = async (currencyId, type, ledgerAccountTypeId
 
 const getEndpoint = async (participantId, endpointType) => {
   try {
-    return Db.participantEndpoint.query(builder => {
+    return Db.from('participantEndpoint').query(builder => {
       return builder.innerJoin('endpointType AS et', 'participantEndpoint.endpointTypeId', 'et.endpointTypeId')
         .where({
           'participantEndpoint.participantId': participantId,
@@ -175,7 +221,7 @@ const getEndpoint = async (participantId, endpointType) => {
 
 const getAllEndpoints = async (participantId) => {
   try {
-    return Db.participantEndpoint.query(builder => {
+    return Db.from('participantEndpoint').query(builder => {
       return builder.innerJoin('endpointType AS et', 'participantEndpoint.endpointTypeId', 'et.endpointTypeId')
         .where({
           'participantEndpoint.participantId': participantId,
@@ -219,7 +265,7 @@ const addEndpoint = async (participantId, endpoint) => {
 
         const existingEndpoint = await knex('participantEndpoint').transacting(trx).forUpdate().select('*')
           .where({
-            participantId: participantId,
+            participantId,
             endpointTypeId: endpointType.endpointTypeId,
             isActive: 1
           })
@@ -227,7 +273,7 @@ const addEndpoint = async (participantId, endpoint) => {
           await knex('participantEndpoint').transacting(trx).update({ isActive: 0 }).where('participantEndpointId', existingEndpoint[0].participantEndpointId)
         }
         const newEndpoint = {
-          participantId: participantId,
+          participantId,
           endpointTypeId: endpointType.endpointTypeId,
           value: endpoint.value,
           isActive: 1,
@@ -248,27 +294,72 @@ const addEndpoint = async (participantId, endpoint) => {
 }
 
 const getParticipantLimitByParticipantCurrencyLimit = async (participantId, currencyId, ledgerAccountTypeId, participantLimitTypeId) => {
+  const histGetParticipantLimitEnd = Metrics.getHistogram(
+    'model_participant',
+    'facade_getParticipantLimitByParticipantCurrencyLimit - Metrics for participant model',
+    ['success', 'queryName']
+  ).startTimer()
+
   try {
-    return await Db.participant.query(async (builder) => {
-      return builder
-        .where({
-          'participant.participantId': participantId,
-          'pc.currencyId': currencyId,
-          'pc.ledgerAccountTypeId': ledgerAccountTypeId,
-          'pl.participantLimitTypeId': participantLimitTypeId,
-          'participant.isActive': 1,
-          'pc.IsActive': 1,
-          'pl.isActive': 1
-        })
-        .innerJoin('participantCurrency AS pc', 'pc.participantId', 'participant.participantId')
-        .innerJoin('participantLimit AS pl', 'pl.participantCurrencyId', 'pc.participantCurrencyId')
-        .select(
-          'participant.participantID AS participantId',
-          'pc.currencyId AS currencyId',
-          'pl.participantLimitTypeId as participantLimitTypeId',
-          'pl.value AS value'
-        ).first()
-    })
+    let participantLimit
+    if (Cache.isCacheEnabled()) {
+      /* Cached version - fetch data from Models (which we trust are cached) */
+      const participant = await ParticipantModelCached.getById(participantId)
+
+      /* Checkpoint #1: participant found and is active */
+      if ((participant) && (participant.isActive)) {
+        /* use the paricipant id and incoming params to prepare the filter */
+        const searchFilter = {
+          participantId: participant.participantId,
+          currencyId,
+          ledgerAccountTypeId,
+          isActive: 1
+        }
+
+        /* find the participantCurrency by prepared filter */
+        const participantCurrency = await ParticipantCurrencyModelCached.findOneByParams(searchFilter)
+
+        /* Checkpoint #2: participantCurrency found and is active */
+        if ((participantCurrency) && (participantCurrency.isActive)) {
+          const participantLimitRow = await ParticipantLimitCached.getByParticipantCurrencyId(participantCurrency.participantCurrencyId)
+
+          /* Checkpoint #3: participantLimit found */
+          if ((participantLimitRow) && (participantLimitRow.isActive)) {
+            /* combine all needed info */
+            participantLimit = {
+              participantId,
+              currencyId: participantCurrency.currencyId,
+              participantLimitTypeId: participantLimitRow.participantLimitTypeId,
+              value: participantLimitRow.value
+            }
+          }
+        }
+      }
+    } else {
+      /* Non-cached version - direct call to DB */
+      participantLimit = await Db.from('participant').query(async (builder) => {
+        return builder
+          .where({
+            'participant.participantId': participantId,
+            'pc.currencyId': currencyId,
+            'pc.ledgerAccountTypeId': ledgerAccountTypeId,
+            'pl.participantLimitTypeId': participantLimitTypeId,
+            'participant.isActive': 1,
+            'pc.IsActive': 1,
+            'pl.isActive': 1
+          })
+          .innerJoin('participantCurrency AS pc', 'pc.participantId', 'participant.participantId')
+          .innerJoin('participantLimit AS pl', 'pl.participantCurrencyId', 'pc.participantCurrencyId')
+          .select(
+            'participant.participantId AS participantId',
+            'pc.currencyId AS currencyId',
+            'pl.participantLimitTypeId as participantLimitTypeId',
+            'pl.value AS value'
+          ).first()
+      })
+    }
+    histGetParticipantLimitEnd({ success: true, queryName: 'facade_getParticipantLimitByParticipantCurrencyLimit' })
+    return participantLimit
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -276,7 +367,7 @@ const getParticipantLimitByParticipantCurrencyLimit = async (participantId, curr
 
 const getParticipantPositionByParticipantIdAndCurrencyId = async (participantId, currencyId, ledgerAccountTypeId) => {
   try {
-    return await Db.participant.query(async (builder) => {
+    return await Db.from('participant').query(async (builder) => {
       return builder
         .where({
           'participant.participantId': participantId,
@@ -323,9 +414,7 @@ const addLimitAndInitialPosition = async (participantCurrencyId, settlementAccou
     const knex = Db.getKnex()
     return knex.transaction(async trx => {
       try {
-        let result
         const limitType = await knex('participantLimitType').where({ name: limitPositionObj.limit.type, isActive: 1 }).select('participantLimitTypeId').first()
-        //  let limitType = await trx.first('participantLimitTypeId').from('participantLimitType').where({ 'name': limitPositionObj.limit.type, 'isActive': 1 })
         const participantLimit = {
           participantCurrencyId,
           participantLimitTypeId: limitType.participantLimitTypeId,
@@ -333,33 +422,60 @@ const addLimitAndInitialPosition = async (participantCurrencyId, settlementAccou
           isActive: 1,
           createdBy: 'unknown'
         }
-        result = await knex('participantLimit').transacting(trx).insert(participantLimit)
+        const result = await knex('participantLimit').transacting(trx).insert(participantLimit)
         participantLimit.participantLimitId = result[0]
-        const participantPosition = {
-          participantCurrencyId,
-          value: limitPositionObj.initialPosition,
-          reservedValue: 0
-        }
-        result = await knex('participantPosition').transacting(trx).insert(participantPosition)
-        participantPosition.participantPositionId = result[0]
-        const settlementPosition = {
-          participantCurrencyId: settlementAccountId,
-          value: 0,
-          reservedValue: 0
-        }
-        result = await knex('participantPosition').transacting(trx).insert(settlementPosition)
-        settlementPosition.participantPositionId = result[0]
-        if (setCurrencyActive) { // if the flag is true then set the isActive flag for corresponding participantCurrency record to true
-          await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', participantCurrencyId)
-          await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', settlementAccountId)
-          await ParticipantCurrencyModelCached.invalidateParticipantCurrencyCache()
+
+        const allSettlementModels = await SettlementModelModel.getAll()
+        const settlementModels = allSettlementModels.filter(model => model.currencyId === limitPositionObj.currency)
+        if (Array.isArray(settlementModels) && settlementModels.length > 0) {
+          for (const settlementModel of settlementModels) {
+            const positionAccount = await getByNameAndCurrency(limitPositionObj.name, limitPositionObj.currency, settlementModel.ledgerAccountTypeId)
+            const settlementAccount = await getByNameAndCurrency(limitPositionObj.name, limitPositionObj.currency, settlementModel.settlementAccountTypeId)
+
+            const participantPosition = {
+              participantCurrencyId: positionAccount.participantCurrencyId,
+              value: (settlementModel.ledgerAccountTypeId === Enum.Accounts.LedgerAccountType.POSITION ? limitPositionObj.initialPosition : 0),
+              reservedValue: 0
+            }
+            await knex('participantPosition').transacting(trx).insert(participantPosition)
+
+            const settlementPosition = {
+              participantCurrencyId: settlementAccount.participantCurrencyId,
+              value: 0,
+              reservedValue: 0
+            }
+            await knex('participantPosition').transacting(trx).insert(settlementPosition)
+            if (setCurrencyActive) { // if the flag is true then set the isActive flag for corresponding participantCurrency record to true
+              await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', positionAccount.participantCurrencyId)
+              await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', settlementAccount.participantCurrencyId)
+              await ParticipantCurrencyModelCached.invalidateParticipantCurrencyCache()
+              await ParticipantLimitCached.invalidateParticipantLimitCache()
+            }
+          }
+        } else {
+          const participantPosition = {
+            participantCurrencyId,
+            value: limitPositionObj.initialPosition,
+            reservedValue: 0
+          }
+          const participantPositionResult = await knex('participantPosition').transacting(trx).insert(participantPosition)
+          participantPosition.participantPositionId = participantPositionResult[0]
+          const settlementPosition = {
+            participantCurrencyId: settlementAccountId,
+            value: 0,
+            reservedValue: 0
+          }
+          await knex('participantPosition').transacting(trx).insert(settlementPosition)
+          if (setCurrencyActive) { // if the flag is true then set the isActive flag for corresponding participantCurrency record to true
+            await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', participantCurrencyId)
+            await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', settlementAccountId)
+            await ParticipantCurrencyModelCached.invalidateParticipantCurrencyCache()
+            await ParticipantLimitCached.invalidateParticipantLimitCache()
+          }
         }
+
         await trx.commit
-        return {
-          participantLimit,
-          participantPosition,
-          settlementPosition
-        }
+        return true
       } catch (err) {
         await trx.rollback
         throw err
@@ -400,7 +516,7 @@ const adjustLimits = async (participantCurrencyId, limit, trx) => {
         // const limitType = await trx.first('participantLimitTypeId').from('participantLimitType').where({ 'name': limit.type, 'isActive': 1 })
         const existingLimit = await knex('participantLimit').transacting(trx).forUpdate().select('*')
           .where({
-            participantCurrencyId: participantCurrencyId,
+            participantCurrencyId,
             participantLimitTypeId: limitType.participantLimitTypeId,
             isActive: 1
           })
@@ -410,7 +526,7 @@ const adjustLimits = async (participantCurrencyId, limit, trx) => {
           throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR, 'Participant Limit does not exist')
         }
         const newLimit = {
-          participantCurrencyId: participantCurrencyId,
+          participantCurrencyId,
           participantLimitTypeId: limitType.participantLimitTypeId,
           value: limit.value,
           thresholdAlarmPercentage: limit.alarmPercentage,
@@ -459,7 +575,7 @@ const adjustLimits = async (participantCurrencyId, limit, trx) => {
 
 const getParticipantLimitsByCurrencyId = async (participantCurrencyId, type) => {
   try {
-    return Db.participantLimit.query(builder => {
+    return Db.from('participantLimit').query(builder => {
       return builder.innerJoin('participantLimitType AS lt', 'participantLimit.participantLimitTypeId', 'lt.participantLimitTypeId')
         .where({
           'participantLimit.participantCurrencyId': participantCurrencyId,
@@ -495,7 +611,7 @@ const getParticipantLimitsByCurrencyId = async (participantCurrencyId, type) =>
 
 const getParticipantLimitsByParticipantId = async (participantId, type, ledgerAccountTypeId) => {
   try {
-    return Db.participantLimit.query(builder => {
+    return Db.from('participantLimit').query(builder => {
       return builder.innerJoin('participantLimitType AS lt', 'participantLimit.participantLimitTypeId', 'lt.participantLimitTypeId')
         .innerJoin('participantCurrency AS pc', 'participantLimit.participantCurrencyId', 'pc.participantCurrencyId')
         .where({
@@ -561,7 +677,7 @@ const addHubAccountAndInitPosition = async (participantId, currencyId, ledgerAcc
 
 const getAllAccountsByNameAndCurrency = async (name, currencyId = null, isAccountActive = 1) => {
   try {
-    return Db.participantCurrency.query(builder => {
+    return Db.from('participantCurrency').query(builder => {
       return builder
         .innerJoin('ledgerAccountType AS lap', 'lap.ledgerAccountTypeId', 'participantCurrency.ledgerAccountTypeId')
         .innerJoin('participant AS p', 'p.participantId', 'participantCurrency.participantId')
@@ -586,6 +702,39 @@ const getAllAccountsByNameAndCurrency = async (name, currencyId = null, isAccoun
   }
 }
 
+const getAllNonHubParticipantsWithCurrencies = async (trx) => {
+  try {
+    const HUB_ACCOUNT_NAME = Config.HUB_NAME
+    const knex = Db.getKnex()
+    const trxFunction = async (trx, doCommit = true) => {
+      try {
+        const res = await knex.distinct('participant.participantId', 'pc.participantId', 'pc.currencyId')
+          .from('participant')
+          .innerJoin('participantCurrency as pc', 'participant.participantId', 'pc.participantId')
+          .whereNot('participant.name', HUB_ACCOUNT_NAME)
+          .transacting(trx)
+
+        if (doCommit) {
+          await trx.commit
+        }
+        return res
+      } catch (err) {
+        if (doCommit) {
+          await trx.rollback
+        }
+        throw ErrorHandler.Factory.reformatFSPIOPError(err)
+      }
+    }
+    if (trx) {
+      return trxFunction(trx, false)
+    } else {
+      return knex.transaction(trxFunction)
+    }
+  } catch (err) {
+    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+  }
+}
+
 module.exports = {
   addHubAccountAndInitPosition,
   getByNameAndCurrency,
@@ -600,5 +749,6 @@ module.exports = {
   getParticipantLimitsByCurrencyId,
   getParticipantLimitsByParticipantId,
   getAllAccountsByNameAndCurrency,
-  getLimitsForAllParticipants
+  getLimitsForAllParticipants,
+  getAllNonHubParticipantsWithCurrencies
 }

package/src/models/participant/participant.js

@@ -32,7 +32,8 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
 
 exports.getAll = async () => {
   try {
-    return Db.participant.find({}, { order: 'name asc' })
+    const result = await Db.from('participant').find({}, { order: 'name asc' })
+    return result
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -40,7 +41,7 @@ exports.getAll = async () => {
 
 exports.create = async (participant) => {
   try {
-    const result = await Db.participant.insert({
+    const result = await Db.from('participant').insert({
       name: participant.name,
       createdBy: 'unknown'
     })
@@ -52,7 +53,7 @@ exports.create = async (participant) => {
 
 exports.update = async (participant, isActive) => {
   try {
-    const result = await Db.participant.update({ participantId: participant.participantId }, { isActive })
+    const result = await Db.from('participant').update({ participantId: participant.participantId }, { isActive })
     return result
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
@@ -61,7 +62,7 @@ exports.update = async (participant, isActive) => {
 
 exports.destroyByName = async (name) => {
   try {
-    const result = await Db.participant.destroy({ name: name })
+    const result = await Db.from('participant').destroy({ name })
     return result
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
@@ -70,7 +71,7 @@ exports.destroyByName = async (name) => {
 
 exports.destroyParticipantEndpointByParticipantId = async (participantId) => {
   try {
-    const result = Db.participantEndpoint.destroy({ participantId: participantId })
+    const result = Db.from('participantEndpoint').destroy({ participantId })
     return result
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)

package/src/models/participant/participantCached.js

@@ -27,6 +27,7 @@
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const Cache = require('../../lib/cache')
 const ParticipantModel = require('../../models/participant/participant')
+const Metrics = require('@mojaloop/central-services-metrics')
 
 let cacheClient
 let participantsAllCacheKey
@@ -62,6 +63,11 @@ const buildUnifiedParticipantsData = (allParticipants) => {
 }
 
 const getParticipantsCached = async () => {
+  const histTimer = Metrics.getHistogram(
+    'model_participant',
+    'model_getParticipantsCached - Metrics for participant model',
+    ['success', 'queryName', 'hit']
+  ).startTimer()
   // Do we have valid participants list in the cache ?
   let cachedParticipants = cacheClient.get(participantsAllCacheKey)
   if (!cachedParticipants) {
@@ -71,9 +77,11 @@ const getParticipantsCached = async () => {
 
     // store in cache
     cacheClient.set(participantsAllCacheKey, cachedParticipants)
+    histTimer({ success: true, queryName: 'model_getParticipantsCached', hit: false })
   } else {
     // unwrap participants list from catbox structure
     cachedParticipants = cachedParticipants.item
+    histTimer({ success: true, queryName: 'model_getParticipantsCached', hit: true })
   }
   return cachedParticipants
 }

package/src/models/participant/participantCurrency.js

@@ -29,7 +29,7 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
 
 exports.create = async (participantId, currencyId, ledgerAccountTypeId, isActive = true) => {
   try {
-    return await Db.participantCurrency.insert({
+    return await Db.from('participantCurrency').insert({
       participantId,
       currencyId,
       ledgerAccountTypeId,
@@ -43,7 +43,7 @@ exports.create = async (participantId, currencyId, ledgerAccountTypeId, isActive
 
 exports.getAll = async () => {
   try {
-    return Db.participantCurrency.find({}, { order: 'participantCurrencyId asc' })
+    return Db.from('participantCurrency').find({}, { order: 'participantCurrencyId asc' })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -51,7 +51,7 @@ exports.getAll = async () => {
 
 exports.getById = async (id) => {
   try {
-    return await Db.participantCurrency.findOne({ participantCurrencyId: id })
+    return await Db.from('participantCurrency').findOne({ participantCurrencyId: id })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -59,7 +59,7 @@ exports.getById = async (id) => {
 
 exports.update = async (participantCurrencyId, isActive) => {
   try {
-    return await Db.participantCurrency.update({ participantCurrencyId }, { isActive })
+    return await Db.from('participantCurrency').update({ participantCurrencyId }, { isActive })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -71,7 +71,7 @@ exports.getByParticipantId = async (id, ledgerAccountTypeId = null) => {
     if (ledgerAccountTypeId) {
       params.ledgerAccountTypeId = ledgerAccountTypeId
     }
-    return await Db.participantCurrency.find(params)
+    return await Db.from('participantCurrency').find(params)
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -79,7 +79,7 @@ exports.getByParticipantId = async (id, ledgerAccountTypeId = null) => {
 
 exports.destroyByParticipantId = async (id) => {
   try {
-    return await Db.participantCurrency.destroy({ participantId: id })
+    return await Db.from('participantCurrency').destroy({ participantId: id })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -87,7 +87,7 @@ exports.destroyByParticipantId = async (id) => {
 
 exports.getByName = async (accountParams) => {
   try {
-    const participantCurrency = await Db.participantCurrency.findOne(accountParams)
+    const participantCurrency = await Db.from('participantCurrency').findOne(accountParams)
     return participantCurrency
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)

package/src/models/participant/participantCurrencyCached.js

@@ -28,6 +28,7 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const Cache = require('../../lib/cache')
 const Config = require('../../../src/lib/config')
 const ParticipantCurrencyModel = require('../../models/participant/participantCurrency')
+const Metrics = require('@mojaloop/central-services-metrics')
 
 let cacheClient
 let participantCurrencyAllCacheKey
@@ -59,6 +60,11 @@ const buildUnifiedParticipantsCurrencyData = (allCurrencyParticipants) => {
 }
 
 const getParticipantCurrencyCached = async () => {
+  const histTimer = Metrics.getHistogram(
+    'model_participant',
+    'model_getParticipantCurrencyCached - Metrics for participant model',
+    ['success', 'queryName', 'hit']
+  ).startTimer()
   // Do we have valid participantsCurrency list in the cache ?
   let cachedCurrencyParticipants = cacheClient.get(participantCurrencyAllCacheKey)
   if (!cachedCurrencyParticipants) {
@@ -68,9 +74,11 @@ const getParticipantCurrencyCached = async () => {
 
     // store in cache
     cacheClient.set(participantCurrencyAllCacheKey, cachedCurrencyParticipants)
+    histTimer({ success: true, queryName: 'model_getParticipantCurrencyCached', hit: false })
   } else {
     // unwrap participants list from catbox structure
     cachedCurrencyParticipants = cachedCurrencyParticipants.item
+    histTimer({ success: true, queryName: 'model_getParticipantCurrencyCached', hit: true })
   }
   return cachedCurrencyParticipants
 }
@@ -90,7 +98,9 @@ exports.initialize = async () => {
 }
 
 exports.invalidateParticipantCurrencyCache = async () => {
-  cacheClient.drop(participantCurrencyAllCacheKey)
+  if (cacheClient) {
+    cacheClient.drop(participantCurrencyAllCacheKey)
+  }
 }
 
 exports.getByParticipantId = async (id, ledgerAccountTypeId = null) => {