@mojaloop/central-ledger 19.11.4-cache.2 → 19.11.4-cache.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-ledger",
-  "version": "19.11.4-cache.2",
+  "version": "19.11.4-cache.3",
   "description": "Central ledger hosted by a scheme to record and settle transfers",
   "license": "Apache-2.0",
   "author": "ModusBox",

package/src/lib/cache.js

@@ -6,55 +6,65 @@ const Config = require('../lib/config')
 
 const expiresIn = parseInt(Config.CACHE_CONFIG.EXPIRES_IN_MS)
 // Init memory client
-const catboxMemoryClient = new CatboxMemory.Engine({ maxByteSize: Config.CACHE_CONFIG.MAX_BYTE_SIZE })
-catboxMemoryClient.start()
+let catboxMemoryClient
 
 class CacheClient {
-  constructor (segment, generateFunc) {
+  constructor (segment, generateFunc, preloadCache) {
     this.generateFunc = generateFunc
-    if (Config.CACHE_CONFIG.CACHE_ENABLED) this.policy = new Catbox.Policy({ generateFunc, expiresIn, generateTimeout: false }, catboxMemoryClient, segment)
+    this.segment = segment
+    this.preloadCache = preloadCache
+  }
+
+  async initCache (catboxMemoryClient) {
+    if (catboxMemoryClient) {
+      this.policy = new Catbox.Policy({
+        generateFunc: this.generateFunc,
+        expiresIn,
+        generateTimeout: false
+      },
+      catboxMemoryClient,
+      this.segment
+      )
+    }
+    return await this.preloadCache?.()
   }
 
   get (key) {
-    return Config.CACHE_CONFIG.CACHE_ENABLED ? this.policy.get(key) : this.generateFunc(key)
+    return this.policy ? this.policy.get(key) : this.generateFunc(key)
   }
 
   drop (key) {
     return this.policy?.drop(key)
   }
-
-  setGenerateFunc (generateFunc) {
-    this.policy?.options({ generateFunc, expiresIn, generateTimeout: false })
-  }
 }
 
-/*
-  Each client should register itself during module load.
-  The client meta should be:
-  {
-    id [MANDATORY]
-    preloadCache() [OPTIONAL]
-      this will be called to preload data
-  }
-*/
 let cacheClients = {}
 
-const registerCacheClient = (id, generateFunc) => {
-  const newClient = new CacheClient(id, generateFunc)
+const registerCacheClient = ({ id, preloadCache, generate }) => {
+  const newClient = new CacheClient(id, generate, preloadCache)
   cacheClients[id] = newClient
   return newClient
 }
 
 const initCache = async function () {
-  // Read config
-  for (const client of Object.values(cacheClients)) {
-    await client.get('all') // preload cache
+  if (isCacheEnabled()) {
+    // Init catbox.
+    catboxMemoryClient = new CatboxMemory.Engine({
+      maxByteSize: Config.CACHE_CONFIG.MAX_BYTE_SIZE
+    })
+    await catboxMemoryClient.start()
+
+    // Init each registered cache client
+    for (const client of Object.values(cacheClients)) {
+      await client.initCache(catboxMemoryClient)
+    }
+  } else {
+    catboxMemoryClient = null
   }
 }
 
 const destroyCache = async function () {
-  catboxMemoryClient.stop()
-  catboxMemoryClient.start()
+  catboxMemoryClient?.stop()
 }
 
 const dropClients = function () {
@@ -75,6 +85,6 @@ module.exports = {
   isCacheEnabled,
 
   // exposed for tests
-  Catbox,
+  CatboxMemory,
   dropClients
 }

package/src/lib/enumCached.js

@@ -38,7 +38,7 @@ const enumAllCacheKey = 'all'
 */
 const _getAllEnums = () => cacheClient.get(enumAllCacheKey)
 
-const generateFunc = async function (key) {
+const generate = async function (key) {
   const allEnums = {}
   for (const enumId of Enums.enumsIds) {
     allEnums[enumId] = await Enums[enumId]()
@@ -59,7 +59,7 @@ exports.getEnums = async (id) => {
 
 exports.initialize = async () => {
   /* Register as cache client */
-  cacheClient = Cache.registerCacheClient('enum', generateFunc)
+  cacheClient = Cache.registerCacheClient({ id: 'enum', generate, preloadCache: _getAllEnums })
 }
 
 exports.invalidateEnumCache = async () => {

package/src/models/participant/externalParticipantCached.js

@@ -53,7 +53,7 @@ const buildUnifiedCachedData = (allExternalParticipants) => {
 
 const getExternalParticipantsCached = () => cacheClient.get(epAllCacheKey)
 
-const generateFunc = async function (key) {
+const generate = async function (key) {
   const allParticipants = await externalParticipantModel.getAll()
   return buildUnifiedCachedData(allParticipants)
 }
@@ -63,7 +63,7 @@ const generateFunc = async function (key) {
 */
 const initialize = () => {
   /* Register as cache client */
-  cacheClient = cache.registerCacheClient('externalParticipants', generateFunc)
+  cacheClient = cache.registerCacheClient({ id: 'externalParticipants', generate, preloadCache: getExternalParticipantsCached })
 }
 
 const invalidateCache = async () => {

package/src/models/participant/participantCached.js

@@ -66,7 +66,7 @@ const buildUnifiedParticipantsData = (allParticipants) => {
 
 const getParticipantsCached = () => cacheClient.get(participantsAllCacheKey)
 
-const generateFunc = async function (key) {
+const generate = async function (key) {
   const allParticipants = await ParticipantModel.getAll()
   return buildUnifiedParticipantsData(allParticipants)
 }
@@ -75,7 +75,7 @@ const generateFunc = async function (key) {
   Public API
 */
 exports.initialize = async () => {
-  cacheClient = Cache.registerCacheClient('participants', generateFunc)
+  cacheClient = Cache.registerCacheClient({ id: 'participants', generate, preloadCache: getParticipantsCached })
 }
 
 exports.invalidateParticipantsCache = async () => {

package/src/models/participant/participantCurrencyCached.js

@@ -63,7 +63,7 @@ const buildUnifiedParticipantsCurrencyData = (allCurrencyParticipants) => {
 
 const getParticipantCurrencyCached = () => cacheClient.get(participantCurrencyAllCacheKey)
 
-const generateFunc = async function (key) {
+const generate = async function (key) {
   const allCurrencyParticipants = await ParticipantCurrencyModel.getAll()
   return buildUnifiedParticipantsCurrencyData(allCurrencyParticipants)
 }
@@ -73,7 +73,7 @@ const generateFunc = async function (key) {
 */
 exports.initialize = async () => {
   /* Register as cache client */
-  cacheClient = Cache.registerCacheClient('participantCurrency', generateFunc)
+  cacheClient = Cache.registerCacheClient({ id: 'participantCurrency', generate, preloadCache: getParticipantCurrencyCached })
 }
 
 exports.invalidateParticipantCurrencyCache = async () => {

package/src/models/participant/participantLimitCached.js

@@ -62,7 +62,7 @@ const buildUnifiedParticipantsLimitData = (allLimitParticipants) => {
 
 const getParticipantLimitCached = () => cacheClient.get(participantLimitAllCacheKey)
 
-const generateFunc = async function (key) {
+const generate = async function (key) {
   const allLimitParticipants = await ParticipantLimitModel.getAll()
   return buildUnifiedParticipantsLimitData(allLimitParticipants)
 }
@@ -72,7 +72,7 @@ const generateFunc = async function (key) {
 */
 exports.initialize = async () => {
   /* Register as cache client */
-  cacheClient = Cache.registerCacheClient('participantLimit', generateFunc)
+  cacheClient = Cache.registerCacheClient({ id: 'participantLimit', generate, preloadCache: getParticipantLimitCached })
 }
 
 exports.invalidateParticipantLimitCache = async () => {

package/src/models/position/batchCached.js

@@ -71,7 +71,7 @@ const buildUnifiedParticipantCurrencyData = (allParticipantCurrency) => {
 
 const getParticipantCurrencyCached = (trx) => cacheClient.get({ id: participantCurrencyAllCacheKey, trx })
 
-const generateFunc = async function (key) {
+const generate = async function (key) {
   const allParticipantCurrency = await BatchPositionModel.getAllParticipantCurrency(key.trx)
   return buildUnifiedParticipantCurrencyData(allParticipantCurrency)
 }
@@ -81,7 +81,7 @@ const generateFunc = async function (key) {
 */
 exports.initialize = async () => {
   /* Register as cache client */
-  cacheClient = Cache.registerCacheClient('positionBatch', generateFunc)
+  cacheClient = Cache.registerCacheClient({ id: 'positionBatch', generate, preloadCache: getParticipantCurrencyCached })
 }
 
 exports.getParticipantCurrencyByIds = async (trx, participantCurrencyIds) => {

package/src/models/settlement/settlementModelCached.js

@@ -64,7 +64,7 @@ const buildUnifiedSettlementModelsData = (allSettlementModels) => {
 
 const getSettlementModelsCached = () => cacheClient.get(settlementModelsAllCacheKey)
 
-const generateFunc = async function (key) {
+const generate = async function (key) {
   const allSettlementModels = await SettlementModel.getAll()
   return buildUnifiedSettlementModelsData(allSettlementModels)
 }
@@ -74,7 +74,7 @@ const generateFunc = async function (key) {
 */
 exports.initialize = async () => {
   /* Register as cache client */
-  cacheClient = Cache.registerCacheClient('settlementModels', generateFunc)
+  cacheClient = Cache.registerCacheClient({ id: 'settlementModels', generate, preloadCache: getSettlementModelsCached })
 }
 
 exports.invalidateSettlementModelsCache = async () => {