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

package/src/models/transfer/transfer.js

@@ -30,25 +30,25 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
 
 const getById = async (transferId) => {
   try {
-    return await Db.transfer.findOne({ transferId: transferId })
+    return await Db.from('transfer').findOne({ transferId })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const saveTransfer = async (record) => {
-  Logger.debug('save transfer' + record.toString())
+  Logger.isDebugEnabled && Logger.debug('save transfer' + record.toString())
   try {
-    return Db.transfer.insert(record)
+    return Db.from('transfer').insert(record)
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
 
 const destroyById = async (id) => {
   try {
-    await Db.transfer.destroy({ transferId: id })
+    await Db.from('transfer').destroy({ transferId: id })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -56,9 +56,9 @@ const destroyById = async (id) => {
 
 const truncateTransfer = async () => {
   try {
-    return await Db.transfer.truncate()
+    return await Db.from('transfer').truncate()
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }

package/src/models/transfer/transferDuplicateCheck.js

@@ -31,7 +31,7 @@
 const Db = require('../../lib/db')
 const Logger = require('@mojaloop/central-services-logger')
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
-
+const Metrics = require('@mojaloop/central-services-metrics')
 /**
  * @function GetTransferDuplicateCheck
  *
@@ -44,10 +44,18 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
  */
 
 const getTransferDuplicateCheck = async (transferId) => {
-  Logger.debug(`get transferDuplicateCheck (transferId=${transferId})`)
+  const histTimerGetTransferDuplicateCheckEnd = Metrics.getHistogram(
+    'model_transfer',
+    'transferDuplicateCheck_getTransferDuplicateCheck - Metrics for transfer duplicate check model',
+    ['success', 'queryName']
+  ).startTimer()
+  Logger.isDebugEnabled && Logger.debug(`get transferDuplicateCheck (transferId=${transferId})`)
   try {
-    return Db.transferDuplicateCheck.findOne({ transferId })
+    const result = Db.from('transferDuplicateCheck').findOne({ transferId })
+    histTimerGetTransferDuplicateCheckEnd({ success: true, queryName: 'transferDuplicateCheck_getTransferDuplicateCheck' })
+    return result
   } catch (err) {
+    histTimerGetTransferDuplicateCheckEnd({ success: false, queryName: 'transferDuplicateCheck_getTransferDuplicateCheck' })
     throw new Error(err.message)
   }
 }
@@ -65,10 +73,18 @@ const getTransferDuplicateCheck = async (transferId) => {
  */
 
 const saveTransferDuplicateCheck = async (transferId, hash) => {
-  Logger.debug(`save transferDuplicateCheck (transferId=${transferId}, hash=${hash})`)
+  const histTimerSaveTransferDuplicateCheckEnd = Metrics.getHistogram(
+    'model_transfer',
+    'transferDuplicateCheck_saveTransferDuplicateCheck - Metrics for transfer duplicate check model',
+    ['success', 'queryName']
+  ).startTimer()
+  Logger.isDebugEnabled && Logger.debug(`save transferDuplicateCheck (transferId=${transferId}, hash=${hash})`)
   try {
-    return Db.transferDuplicateCheck.insert({ transferId, hash })
+    const result = Db.from('transferDuplicateCheck').insert({ transferId, hash })
+    histTimerSaveTransferDuplicateCheckEnd({ success: true, queryName: 'transferDuplicateCheck_saveTransferDuplicateCheck' })
+    return result
   } catch (err) {
+    histTimerSaveTransferDuplicateCheckEnd({ success: false, queryName: 'transferDuplicateCheck_saveTransferDuplicateCheck' })
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }

package/src/models/transfer/transferError.js

@@ -47,9 +47,9 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
  */
 
 const insert = async (transferId, transferStateChangeId, errorCode, errorDescription) => {
-  Logger.debug(`insert transferError - errorCode: ${errorCode}, errorDesc: ${errorDescription}`)
+  Logger.isDebugEnabled && Logger.debug(`insert transferError - errorCode: ${errorCode}, errorDesc: ${errorDescription}`)
   try {
-    return Db.transferError.insert({ transferId, transferStateChangeId, errorCode, errorDescription })
+    return Db.from('transferError').insert({ transferId, transferStateChangeId, errorCode, errorDescription })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -78,7 +78,7 @@ const insert = async (transferId, transferStateChangeId, errorCode, errorDescrip
 
 const getByTransferStateChangeId = async (transferStateChangeId) => {
   try {
-    return Db.transferError.find({ transferStateChangeId: transferStateChangeId })
+    return Db.from('transferError').find({ transferStateChangeId })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -107,7 +107,7 @@ const getByTransferStateChangeId = async (transferStateChangeId) => {
 
 const getByTransferId = async (id) => {
   try {
-    const transferError = await Db.transferError.query(async (builder) => {
+    const transferError = await Db.from('transferError').query(async (builder) => {
       const result = builder
         .where({ transferId: id })
         .select('*')
@@ -117,7 +117,7 @@ const getByTransferId = async (id) => {
     transferError.errorCode = transferError.errorCode.toString()
     return transferError
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }

package/src/models/transfer/transferErrorDuplicateCheck.js

@@ -44,9 +44,9 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
  */
 
 const getTransferErrorDuplicateCheck = async (transferId) => {
-  Logger.debug(`get transferErrorDuplicateCheck (transferId=${transferId})`)
+  Logger.isDebugEnabled && Logger.debug(`get transferErrorDuplicateCheck (transferId=${transferId})`)
   try {
-    return Db.transferErrorDuplicateCheck.findOne({ transferId })
+    return Db.from('transferErrorDuplicateCheck').findOne({ transferId })
   } catch (err) {
     throw new Error(err.message)
   }
@@ -65,9 +65,9 @@ const getTransferErrorDuplicateCheck = async (transferId) => {
  */
 
 const saveTransferErrorDuplicateCheck = async (transferId, hash) => {
-  Logger.debug(`save transferErrorDuplicateCheck (transferId=${transferId}, hash=${hash})`)
+  Logger.isDebugEnabled && Logger.debug(`save transferErrorDuplicateCheck (transferId=${transferId}, hash=${hash})`)
   try {
-    return Db.transferErrorDuplicateCheck.insert({ transferId, hash })
+    return Db.from('transferErrorDuplicateCheck').insert({ transferId, hash })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }

package/src/models/transfer/transferExtension.js

@@ -32,7 +32,7 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
 
 const saveTransferExtension = async (extension) => {
   try {
-    return await Db.transferExtension.insert(extension)
+    return await Db.from('transferExtension').insert(extension)
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -40,7 +40,7 @@ const saveTransferExtension = async (extension) => {
 
 const getByTransferId = async (transferId, isFulfilment = false, isError = false) => {
   try {
-    return await Db.transferExtension.find({ transferId, isFulfilment, isError })
+    return await Db.from('transferExtension').find({ transferId, isFulfilment, isError })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -48,7 +48,7 @@ const getByTransferId = async (transferId, isFulfilment = false, isError = false
 
 const getByTransferExtensionId = async (transferExtensionId) => {
   try {
-    return await Db.transferExtension.findOne({ transferExtensionId })
+    return await Db.from('transferExtension').findOne({ transferExtensionId })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -56,7 +56,7 @@ const getByTransferExtensionId = async (transferExtensionId) => {
 
 const destroyByTransferId = async (transferId) => {
   try {
-    return await Db.transferExtension.destroy({ transferId })
+    return await Db.from('transferExtension').destroy({ transferId })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }

package/src/models/transfer/transferFulfilment.js

@@ -29,20 +29,20 @@ const Logger = require('@mojaloop/central-services-logger')
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 
 const getByTransferId = async (transferId) => {
-  Logger.debug('getByTransferId ' + transferId.toString())
+  Logger.isDebugEnabled && Logger.debug('getByTransferId ' + transferId.toString())
   try {
-    return await Db.transferFulfilment.find({ transferId: transferId })
+    return await Db.from('transferFulfilment').find({ transferId })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const saveTransferFulfilment = async (record) => {
-  Logger.debug('save transferFulfilment ' + record.toString())
+  Logger.isDebugEnabled && Logger.debug('save transferFulfilment ' + record.toString())
   try {
-    return await Db.transferFulfilment.insert(record)
+    return await Db.from('transferFulfilment').insert(record)
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }

package/src/models/transfer/transferFulfilmentDuplicateCheck.js

@@ -44,9 +44,9 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
  */
 
 const getTransferFulfilmentDuplicateCheck = async (transferId) => {
-  Logger.debug(`get transferFulfilmentDuplicateCheck (transferId=${transferId})`)
+  Logger.isDebugEnabled && Logger.debug(`get transferFulfilmentDuplicateCheck (transferId=${transferId})`)
   try {
-    return Db.transferFulfilmentDuplicateCheck.findOne({ transferId })
+    return Db.from('transferFulfilmentDuplicateCheck').findOne({ transferId })
   } catch (err) {
     throw new Error(err.message)
   }
@@ -65,9 +65,9 @@ const getTransferFulfilmentDuplicateCheck = async (transferId) => {
  */
 
 const saveTransferFulfilmentDuplicateCheck = async (transferId, hash) => {
-  Logger.debug(`save transferFulfilmentDuplicateCheck (transferId=${transferId}, hash=${hash})`)
+  Logger.isDebugEnabled && Logger.debug(`save transferFulfilmentDuplicateCheck (transferId=${transferId}, hash=${hash})`)
   try {
-    return Db.transferFulfilmentDuplicateCheck.insert({ transferId, hash })
+    return Db.from('transferFulfilmentDuplicateCheck').insert({ transferId, hash })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }

package/src/models/transfer/transferParticipant.js

@@ -28,11 +28,11 @@ const Db = require('../../lib/db')
 const Logger = require('@mojaloop/central-services-logger')
 
 const saveTransferParticipant = async (record) => {
-  Logger.debug('save transferParticipant' + record.toString())
+  Logger.isDebugEnabled && Logger.debug('save transferParticipant' + record.toString())
   try {
-    return await Db.transferParticipant.insert(record)
+    return await Db.from('transferParticipant').insert(record)
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }

package/src/models/transfer/transferStateChange.js

@@ -30,18 +30,18 @@ const Db = require('../../lib/db')
 const Logger = require('@mojaloop/central-services-logger')
 
 const saveTransferStateChange = async (stateChange) => {
-  Logger.debug('save transferStateChange' + stateChange.toString())
+  Logger.isDebugEnabled && Logger.debug('save transferStateChange' + stateChange.toString())
   try {
-    return Db.transferStateChange.insert(stateChange)
+    return Db.from('transferStateChange').insert(stateChange)
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
 
 const getByTransferId = async (id) => {
   try {
-    return await Db.transferStateChange.query(async (builder) => {
+    return await Db.from('transferStateChange').query(async (builder) => {
       const result = builder
         .where({ 'transferStateChange.transferId': id })
         .select('transferStateChange.*')
@@ -50,43 +50,43 @@ const getByTransferId = async (id) => {
       return result
     })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
 
 const getByTransferIdList = async (transfersIdList) => {
   try {
-    return await Db.transferStateChange.query(async (builder) => {
+    return await Db.from('transferStateChange').query(async (builder) => {
       const result = builder
         .whereIn('transferStateChange.transferId', transfersIdList)
       return result
     })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
 
 const getLatest = async () => {
   try {
-    return await Db.transferStateChange.query(async (builder) => {
+    return await Db.from('transferStateChange').query(async (builder) => {
       return builder
         .select('transferStateChangeId')
         .orderBy('transferStateChangeId', 'desc')
         .first()
     })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
 
 const truncate = async () => {
   try {
-    return await Db.transferStateChange.truncate()
+    return await Db.from('transferStateChange').truncate()
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }

package/src/models/transfer/transferTimeout.js

@@ -30,14 +30,14 @@ const Enum = require('@mojaloop/central-services-shared').Enum
 const TS = Enum.Transfers.TransferInternalState
 
 const cleanup = async () => {
-  Logger.debug('cleanup transferTimeout')
+  Logger.isDebugEnabled && Logger.debug('cleanup transferTimeout')
   try {
     const knex = await Db.getKnex()
 
-    const ttIdList = await Db.transferTimeout.query(async (builder) => {
+    const ttIdList = await Db.from('transferTimeout').query(async (builder) => {
       const b = await builder
         .whereIn('tsc.transferStateId', [`${TS.RECEIVED_FULFIL}`, `${TS.COMMITTED}`, `${TS.FAILED}`, `${TS.RESERVED_TIMEOUT}`,
-          `${TS.RECEIVED_REJECT}`, `${TS.EXPIRED_PREPARED}`, `${TS.EXPIRED_RESERVED}`, `${TS.ABORTED_REJECTED}`])
+          `${TS.RECEIVED_REJECT}`, `${TS.EXPIRED_PREPARED}`, `${TS.EXPIRED_RESERVED}`, `${TS.ABORTED_REJECTED}`, `${TS.ABORTED_ERROR}`])
         .innerJoin(
           knex('transferTimeout AS tt1')
             .select('tsc1.transferId')
@@ -50,7 +50,7 @@ const cleanup = async () => {
       return b
     })
 
-    await Db.transferTimeout.query(async (builder) => {
+    await Db.from('transferTimeout').query(async (builder) => {
       const b = await builder
         .whereIn('transferTimeout.transferTimeoutId', ttIdList.map(elem => elem.transferTimeoutId))
         .del()
@@ -58,7 +58,7 @@ const cleanup = async () => {
     })
     return ttIdList
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }

package/src/schema/bulkTransfer.js

@@ -116,12 +116,12 @@ bulkTransferSchema.pre('save', function () {
         })
         await individualTransfer.save()
       } catch (err) {
-        Logger.error(err)
+        Logger.isErrorEnabled && Logger.error(err)
         throw err
       }
     })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 })
@@ -202,12 +202,12 @@ bulkTransferResponseSchema.pre('save', function () {
         })
         await individualTransferResult.save()
       } catch (err) {
-        Logger.error(err)
+        Logger.isErrorEnabled && Logger.error(err)
         throw err
       }
     })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 })

package/src/shared/plugins.js

@@ -1,21 +1,22 @@
 'use strict'
 
-const Package = require('../../package')
+const Path = require('path')
 const Inert = require('@hapi/inert')
 const Vision = require('@hapi/vision')
 const Blipp = require('blipp')
 const ErrorHandling = require('@mojaloop/central-services-error-handling')
+const APIDocumentation = require('@mojaloop/central-services-shared').Util.Hapi.APIDocumentation
+const Config = require('../lib/config')
 
 const registerPlugins = async (server) => {
-  await server.register({
-    plugin: require('hapi-swagger'),
-    options: {
-      info: {
-        title: 'Central Ledger API Documentation',
-        version: Package.version
+  if (Config.API_DOC_ENDPOINTS_ENABLED) {
+    await server.register({
+      plugin: APIDocumentation,
+      options: {
+        documentPath: Path.resolve(__dirname, '../api/interface/swagger.json')
       }
-    }
-  })
+    })
+  }
 
   await server.register({
     plugin: require('@hapi/good'),

package/src/shared/setup.js

@@ -36,10 +36,9 @@
 const Hapi = require('@hapi/hapi')
 const Migrator = require('../lib/migrator')
 const Db = require('../lib/db')
-const ObjStoreDb = require('@mojaloop/central-object-store').Db
+const ObjStoreDb = require('@mojaloop/object-store-lib').Db
 const Plugins = require('./plugins')
 const Config = require('../lib/config')
-const Sidecar = require('../lib/sidecar')
 const RequestLogger = require('../lib/requestLogger')
 const Uuid = require('uuid4')
 const UrlParser = require('../lib/urlParser')
@@ -48,23 +47,34 @@ const RegisterHandlers = require('../handlers/register')
 const Metrics = require('@mojaloop/central-services-metrics')
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const Cache = require('../lib/cache')
+const EnumCached = require('../lib/enumCached')
 const ParticipantCached = require('../models/participant/participantCached')
 const ParticipantCurrencyCached = require('../models/participant/participantCurrencyCached')
+const ParticipantLimitCached = require('../models/participant/participantLimitCached')
 
 const migrate = (runMigrations) => {
   return runMigrations ? Migrator.migrate() : true
 }
+
 const connectDatabase = async () => {
-  return Db.connect(Config.DATABASE)
+  Logger.isDebugEnabled && Logger.debug(`Connecting to DB ${JSON.stringify(Config.DATABASE)}`)
+  await Db.connect(Config.DATABASE)
+  const dbLoadedTables = Db._tables ? Db._tables.length : -1
+  Logger.isDebugEnabled && Logger.debug(`DB.connect loaded '${dbLoadedTables}' tables!`)
 }
+
 const connectMongoose = async () => {
   if (!Config.MONGODB_DISABLED) {
     try {
+      if (Config.MONGODB_DEBUG) {
+        Logger.isWarnEnabled && Logger.warn('Enabling debug for Mongoose...')
+        ObjStoreDb.Mongoose.set('debug', Config.MONGODB_DEBUG) // enable debug
+      }
       return ObjStoreDb.connect(Config.MONGODB_URI)
     } catch (err) {
       throw ErrorHandler.Factory.reformatFSPIOPError(err)
       // TODO: review as code is being changed from returning null to returning a FSPIOPError
-      // Logger.error(`error - ${err}`)
+      // Logger.isErrorEnabled && Logger.error(`error - ${err}`)
       // return null
     }
   } else {
@@ -94,8 +104,8 @@ const createServer = (port, modules) => {
         }
       }
     })
-    server.ext('onRequest', function (request, h) {
-      const transferId = UrlParser.idFromTransferUri(`${Config.HOSTNAME}${request.url.path}`)
+    server.ext('onPostAuth', function (request, h) {
+      const transferId = UrlParser.idFromTransferUri(`${Config.HOSTNAME}${request.path}`)
       request.headers.traceid = request.headers.traceid || transferId || Uuid()
       RequestLogger.logRequest(request)
       return h.continue
@@ -107,7 +117,7 @@ const createServer = (port, modules) => {
     await Plugins.registerPlugins(server)
     await server.register(modules)
     await server.start()
-    Logger.info('Server running at: ', server.info.uri)
+    Logger.isInfoEnabled && Logger.info(`Server running at: ${server.info.uri}`)
     return server
   })()
 }
@@ -133,17 +143,17 @@ const createHandlers = async (handlers) => {
     ext: {},
     start: new Date(),
     info: {},
-    handlers: handlers
+    handlers
   }
 
   for (const handler of handlers) {
     if (handler.enabled) {
-      Logger.info(`Handler Setup - Registering ${JSON.stringify(handler)}!`)
+      Logger.isInfoEnabled && Logger.info(`Handler Setup - Registering ${JSON.stringify(handler)}!`)
       switch (handler.type) {
         case 'prepare': {
           await RegisterHandlers.transfers.registerPrepareHandler()
           // if (!Config.HANDLERS_CRON_DISABLED) {
-          //   Logger.info('Starting Kafka Cron Jobs...')
+          //   Logger.isInfoEnabled && Logger.info('Starting Kafka Cron Jobs...')
           //   await KafkaCron.start('prepare')
           // }
           break
@@ -151,7 +161,7 @@ const createHandlers = async (handlers) => {
         case 'position': {
           await RegisterHandlers.positions.registerPositionHandler()
           // if (!Config.HANDLERS_CRON_DISABLED) {
-          //   Logger.info('Starting Kafka Cron Jobs...')
+          //   Logger.isInfoEnabled && Logger.info('Starting Kafka Cron Jobs...')
           //   await KafkaCron.start('position')
           // }
           break
@@ -184,9 +194,13 @@ const createHandlers = async (handlers) => {
           await RegisterHandlers.bulk.registerBulkProcessingHandler()
           break
         }
+        case 'bulkget': {
+          await RegisterHandlers.bulk.registerBulkGetHandler()
+          break
+        }
         default: {
           const error = `Handler Setup - ${JSON.stringify(handler)} is not a valid handler to register!`
-          Logger.error(error)
+          Logger.isErrorEnabled && Logger.error(error)
           throw new Error(error)
         }
       }
@@ -203,9 +217,11 @@ const initializeInstrumentation = () => {
 }
 
 const initializeCache = async () => {
-  await Cache.initCache()
+  await EnumCached.initialize()
   await ParticipantCached.initialize()
   await ParticipantCurrencyCached.initialize()
+  await ParticipantLimitCached.initialize()
+  await Cache.initCache()
 }
 
 /**
@@ -228,45 +244,52 @@ const initializeCache = async () => {
  * @returns {object} Returns HTTP Server object
  */
 const initialize = async function ({ service, port, modules = [], runMigrations = false, runHandlers = false, handlers = [] }) {
-  await migrate(runMigrations)
-  await connectDatabase()
-  await connectMongoose()
-  await initializeCache()
-  await Sidecar.connect(service)
-  initializeInstrumentation()
-  let server
-  switch (service) {
-    case 'api':
-    case 'admin': {
-      server = await createServer(port, modules)
-      break
-    }
-    case 'handler': {
-      if (!Config.HANDLERS_API_DISABLED) {
+  try {
+    initializeInstrumentation()
+    await migrate(runMigrations)
+    await connectDatabase()
+    await connectMongoose()
+    await initializeCache()
+
+    let server
+    switch (service) {
+      case 'api':
+      case 'admin': {
         server = await createServer(port, modules)
+        break
+      }
+      case 'handler': {
+        if (!Config.HANDLERS_API_DISABLED) {
+          server = await createServer(port, modules)
+        }
+        break
+      }
+      default: {
+        Logger.isErrorEnabled && Logger.error(`No valid service type ${service} found!`)
+        throw ErrorHandler.Factory.createInternalServerFSPIOPError(`No valid service type ${service} found!`)
       }
-      break
-    }
-    default: {
-      Logger.error(`No valid service type ${service} found!`)
-      throw ErrorHandler.Factory.createInternalServerFSPIOPError(`No valid service type ${service} found!`)
     }
-  }
 
-  if (runHandlers) {
-    if (Array.isArray(handlers) && handlers.length > 0) {
-      await createHandlers(handlers)
-    } else {
-      await RegisterHandlers.registerAllHandlers()
-      // if (!Config.HANDLERS_CRON_DISABLED) {
-      //   Logger.info('Starting Kafka Cron Jobs...')
-      //   // await KafkaCron.start('prepare')
-      //   await KafkaCron.start('position')
-      // }
+    if (runHandlers) {
+      if (Array.isArray(handlers) && handlers.length > 0) {
+        await createHandlers(handlers)
+      } else {
+        await RegisterHandlers.registerAllHandlers()
+        // if (!Config.HANDLERS_CRON_DISABLED) {
+        //   Logger.isInfoEnabled && Logger.info('Starting Kafka Cron Jobs...')
+        //   // await KafkaCron.start('prepare')
+        //   await KafkaCron.start('position')
+        // }
+      }
     }
-  }
 
-  return server
+    return server
+  } catch (err) {
+    Logger.isErrorEnabled && Logger.error(`Error while initializing ${err}`)
+
+    await Db.disconnect()
+    process.exit(1)
+  }
 }
 
 module.exports = {

package/test/integration/domain/participant/index.test.js

@@ -37,6 +37,7 @@ const Config = require('../../../../src/lib/config')
 const ParticipantService = require('../../../../src/domain/participant')
 const ParticipantCached = require('../../../../src/models/participant/participantCached')
 const ParticipantCurrencyCached = require('../../../../src/models/participant/participantCurrencyCached')
+const ParticipantLimitCached = require('../../../../src/models/participant/participantLimitCached')
 const ParticipantHelper = require('../../helpers/participant')
 const ParticipantEndpointHelper = require('../../helpers/participantEndpoint')
 const ParticipantLimitHelper = require('../../helpers/participantLimit')
@@ -67,6 +68,7 @@ Test('Participant service', async (participantTest) => {
       await Db.connect(Config.DATABASE)
       await ParticipantCached.initialize()
       await ParticipantCurrencyCached.initialize()
+      await ParticipantLimitCached.initialize()
       await Cache.initCache()
       test.pass()
       test.end()