ml-testing-toolkit 18.13.0

package/src/lib/api-server.js

@@ -0,0 +1,135 @@
+/*****
+ 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
+ - Name Surname <name.surname@mojaloop.io>
+
+ * ModusBox
+ * Georgi Logodazhki <georgi.logodazhki@modusbox.com>
+ * Vijaya Kumar Guthi <vijaya.guthi@modusbox.com> (Original Author)
+ --------------
+ ******/
+const express = require('express')
+const app = express()
+const http = require('http').Server(app)
+const customLogger = require('./requestLogger')
+const Config = require('./config')
+const passport = require('passport')
+const cookieParser = require('cookie-parser')
+const util = require('util')
+const path = require('path')
+const fs = require('fs')
+const cors = require('cors')
+const OAuthHelper = require('./oauth/OAuthHelper')
+
+const initServer = () => {
+  // For CORS policy
+  app.use(cors({
+    allowedHeaders: ['Origin', 'X-Requested-With', 'Content-Type', 'Accept', 'Authorization'],
+    exposedHeaders: ['Content-Disposition'],
+    methods: ['GET', 'POST', 'PATCH', 'PUT', 'DELETE', 'OPTIONS'],
+    origin: true,
+    credentials: true
+  }))
+
+  // For parsing incoming JSON requests
+  app.use(express.json({ limit: '50mb' }))
+  app.use(express.urlencoded({ extended: true }))
+
+  // For oauth
+  app.use(cookieParser())
+  OAuthHelper.handleMiddleware()
+
+  // Metrics
+  app.use(require('./metrics')(Config.getSystemConfig().METRICS))
+
+  const verifyUserMiddleware = verifyUser()
+  // For admin API
+  app.use('/api/rules', verifyUserMiddleware, require('./api-routes/rules'))
+  app.use('/api/openapi', verifyUserMiddleware, require('./api-routes/openapi'))
+  app.use('/api/outbound', verifyUserMiddleware, require('./api-routes/outbound'))
+  app.use('/api/config', verifyUserMiddleware, require('./api-routes/config'))
+  app.use('/longpolling', verifyUserMiddleware, require('./api-routes/longpolling'))
+  app.use('/api/oauth2', require('./api-routes/oauth2'))
+  app.use('/api/keycloak', verifyUserMiddleware, require('./api-routes/keycloak'))
+  app.use('/api/reports', verifyUserMiddleware, require('./api-routes/reports'))
+  app.use('/api/settings', verifyUserMiddleware, require('./api-routes/settings'))
+  app.use('/api/samples', verifyUserMiddleware, require('./api-routes/samples'))
+  app.use('/api/objectstore', verifyUserMiddleware, require('./api-routes/objectstore'))
+  app.use('/api/history', verifyUserMiddleware, require('./api-routes/history'))
+  app.use('/api/serverlogs', verifyUserMiddleware, require('./api-routes/server-logs'))
+
+  // For front-end UI
+  if (fs.existsSync(path.join('public_html'))) {
+    customLogger.logMessage('info', 'Folder public_html found: Serving Static Web UI', { notification: false })
+    // app.use('*.(jpg|jpeg|gif|png|ico|cur|gz|svg|svgz|mp4|ogg|ogv|webm|htc|css|js)', express.static(path.join('public_html')))
+    app.use(express.static(path.join('public_html')))
+    app.get('*', (req, res) => {
+      res.sendFile(process.cwd() + '/public_html/index.html')
+    })
+  } else {
+    customLogger.logMessage('warn', 'Folder public_html not found', { notification: false })
+  }
+}
+
+const startServer = port => {
+  initServer()
+  http.listen(port)
+  customLogger.logMessage('info', 'API Server started on port ' + port, { notification: false })
+}
+
+const stopServer = port => {
+  http.close()
+  customLogger.logMessage('info', 'API Server stopped', { notification: false })
+}
+
+const getApp = () => {
+  if (!Object.prototype.hasOwnProperty.call(app, '_router')) { // To check whether app is initialized or not
+    initServer()
+  }
+  return app
+}
+const getHttp = () => {
+  return http
+}
+
+const verifyUser = () => {
+  if (Config.getSystemConfig().OAUTH.AUTH_ENABLED) {
+    return (req, res, next) => {
+      req.session = {}
+      passport.authenticate('jwt', { session: false, failureMessage: true })(req, res, next)
+      // failWithError: true returns awful html error. , failureMessage: True to store failure message in req.session.messages, or a string to use as override message for failure.
+      if (res.statusCode === 401) {
+        customLogger.logMessage('error', `Unable to authenticate with passport.authenticate - ${util.inspect(req.session.messages)}`, { additionalData: req.session.messages, notification: false })
+      }
+    }
+    // return passport.authenticate('jwt', { session: false, failWithError: true })
+  }
+  return (req, res, next) => { next() }
+}
+
+module.exports = {
+  startServer,
+  stopServer,
+  getHttp,
+  getApp,
+  verifyUser
+}

package/src/lib/arrayStore.js

@@ -0,0 +1,101 @@
+/*****
+ 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
+ - Name Surname <name.surname@mojaloop.io>
+
+ * ModusBox
+ * Vijaya Kumar Guthi <vijaya.guthi@modusbox.com> (Original Author)
+ --------------
+ ******/
+
+const storedObject = {
+  data: {
+    requestsHistory: [],
+    callbacksHistory: []
+  }
+}
+
+const init = (key, user) => {
+  const context = user ? user.dfspId : 'data'
+  if (!storedObject[context]) {
+    storedObject[context] = {}
+  }
+  if (!storedObject[context][key]) {
+    storedObject[context][key] = []
+  }
+  return context
+}
+
+const reset = (key, user) => {
+  const context = init(key, user)
+  storedObject[context][key] = []
+}
+
+const get = (key, user) => {
+  const context = init(key, user)
+  return [...storedObject[context][key]]
+}
+
+const push = (key, value, user) => {
+  const context = init(key, user)
+  storedObject[context][key].push({
+    insertedDate: Date.now(),
+    data: JSON.parse(JSON.stringify(value))
+  })
+}
+
+const clear = (arrName, interval) => {
+  for (const context in storedObject) {
+    if (storedObject[context][arrName]) {
+      let delEndIndex = -1
+      for (let i = 0; i < storedObject[context][arrName].length; i++) {
+        const timeDiff = Date.now() - storedObject[context][arrName][i].insertedDate
+        if (timeDiff > interval) {
+          delEndIndex = i
+        } else {
+          break
+        }
+      }
+      if (delEndIndex >= 0) {
+        storedObject[context][arrName].splice(0, delEndIndex + 1)
+      }
+    }
+  }
+}
+
+const clearOldObjects = () => {
+  const interval = 10 * 60 * 1000
+  clear('requestsHistory', interval)
+  clear('callbacksHistory', interval)
+}
+
+const initArrayStore = () => {
+  setInterval(clearOldObjects, 1000)
+}
+
+module.exports = {
+  get,
+  reset,
+  initArrayStore,
+  push,
+  clear
+}

package/src/lib/callbackHandler.js

@@ -0,0 +1,201 @@
+/*****
+ 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
+ - Name Surname <name.surname@mojaloop.io>
+
+ * ModusBox
+ * Vijaya Kumar Guthi <vijaya.guthi@modusbox.com> (Original Author)
+ --------------
+ ******/
+
+const customLogger = require('./requestLogger')
+const Config = require('./config')
+const axios = require('axios').default
+const https = require('https')
+const objectStore = require('./objectStore')
+const arrayStore = require('./arrayStore')
+const MyEventEmitter = require('./MyEventEmitter')
+const JwsSigning = require('./jws/JwsSigning')
+const ConnectionProvider = require('./configuration-providers/mb-connection-manager')
+const { TraceHeaderUtils } = require('@mojaloop/ml-testing-toolkit-shared-lib')
+const UniqueIdGenerator = require('./uniqueIdGenerator')
+const httpAgentStore = require('./httpAgentStore')
+
+const handleCallback = async (callbackObject, context, req) => {
+  if (callbackObject.delay) {
+    await new Promise(resolve => setTimeout(resolve, callbackObject.delay))
+  }
+  const userConfig = await Config.getUserConfig(req.customInfo.user)
+  const uniqueId = UniqueIdGenerator.generateUniqueId(req)
+  let callbackEndpoint = userConfig.CALLBACK_ENDPOINT
+
+  const endpointsDfspWise = userConfig.ENDPOINTS_DFSP_WISE
+  if (userConfig.HUB_ONLY_MODE && callbackObject.callbackInfo && callbackObject.callbackInfo.fspid && endpointsDfspWise.dfsps[callbackObject.callbackInfo.fspid]) {
+    const dfspEndpoints = endpointsDfspWise.dfsps[callbackObject.callbackInfo.fspid]
+    const dfspEndpoint = dfspEndpoints.endpoints.find(endpoint => endpoint.method === callbackObject.method && endpoint.path && callbackObject.path && endpoint.endpoint)
+    if (dfspEndpoint) {
+      callbackEndpoint = dfspEndpoint.endpoint
+    } else {
+      callbackEndpoint = dfspEndpoints.defaultEndpoint
+    }
+  } else if (userConfig.CALLBACK_RESOURCE_ENDPOINTS && userConfig.CALLBACK_RESOURCE_ENDPOINTS.enabled) {
+    const callbackEndpoints = userConfig.CALLBACK_RESOURCE_ENDPOINTS
+    const matchedObject = callbackEndpoints.endpoints.find(item => {
+      if (item.method === callbackObject.method) {
+        const path = new RegExp(item.path.replace(/{.*}/, '.*'))
+        return path.test(callbackObject.path)
+      }
+      return false
+    })
+    if (matchedObject && matchedObject.endpoint) {
+      callbackEndpoint = matchedObject.endpoint
+    }
+  }
+
+  // Handle the host header for hub-only requests
+  if (userConfig.HUB_ONLY_MODE && callbackObject.headers && callbackObject.headers.host) {
+    delete callbackObject.headers.host
+  }
+
+  const httpAgentProps = {}
+  let urlGenerated = callbackEndpoint + callbackObject.path
+  if (Config.getSystemConfig().OUTBOUND_MUTUAL_TLS_ENABLED) {
+    const tlsConfig = await ConnectionProvider.getTlsConfig()
+    if (!tlsConfig.dfsps[callbackObject.callbackInfo.fspid]) {
+      const errorMsg = 'Outbound TLS is enabled, but there is no TLS config found for DFSP ID: ' + callbackObject.callbackInfo.fspid
+      customLogger.logMessage('error', errorMsg, { request: req, notification: false })
+      throw errorMsg
+    }
+    const httpsAgent = new https.Agent({
+      cert: tlsConfig.dfsps[callbackObject.callbackInfo.fspid].hubClientCert,
+      key: tlsConfig.hubClientKey,
+      ca: [tlsConfig.dfsps[callbackObject.callbackInfo.fspid].dfspServerCaRootCert],
+      rejectUnauthorized: true
+    })
+    httpsAgent.toJSON = () => ({})
+    httpAgentProps.httpsAgent = httpsAgent
+    urlGenerated = urlGenerated.replace('http:', 'https:')
+  } else if (userConfig.CLIENT_MUTUAL_TLS_ENABLED) {
+    const urlObject = new URL(urlGenerated)
+    const cred = userConfig.CLIENT_TLS_CREDS.filter(item => item.HOST === urlObject.host)
+    if (Array.isArray(cred) && cred.length === 1) {
+      customLogger.logMessage('info', `Found the Client certificate for ${urlObject.host}`, { request: req, notification: false })
+      httpAgentProps.httpsAgent = httpAgentStore.getHttpsAgent(urlObject.host, {
+        cert: cred[0].CERT,
+        key: cred[0].KEY,
+        rejectUnauthorized: false
+      })
+      urlGenerated = urlGenerated.replace('http:', 'https:')
+    } else {
+      const errorMsg = `client mutual TLS is enabled, but there is no TLS config found for ${urlObject.host}`
+      customLogger.logMessage('error', errorMsg, { request: req, notification: false })
+    }
+  } else {
+    if (urlGenerated.startsWith('https:')) {
+      httpAgentProps.httpsAgent = httpAgentStore.getHttpsAgent('generic', {
+        rejectUnauthorized: false
+      })
+    } else {
+      httpAgentProps.httpAgent = httpAgentStore.getHttpAgent('generic')
+    }
+  }
+
+  if (!callbackObject.headers) {
+    callbackObject.headers = {}
+  }
+  // Pass on the traceparent header if exists
+  if (req.headers && req.headers.traceparent) {
+    callbackObject.headers.traceparent = req.headers.traceparent
+  } else {
+    if (req.customInfo && req.customInfo.traceID) {
+      callbackObject.headers.traceparent = TraceHeaderUtils.getTraceParentHeader(req.customInfo.traceID)
+    }
+  }
+
+  const reqOpts = {
+    method: callbackObject.method,
+    url: urlGenerated,
+    path: callbackObject.path,
+    headers: {
+      ...callbackObject.headers
+    },
+    data: callbackObject.body,
+    customInfo: req.customInfo,
+    timeout: userConfig.DEFAULT_REQUEST_TIMEOUT || 3000,
+    ...httpAgentProps
+  }
+
+  // Remove content-length header
+  if (reqOpts.headers['Content-Length']) {
+    delete reqOpts.headers['Content-Length']
+  }
+  if (reqOpts.headers['content-length']) {
+    delete reqOpts.headers['content-length']
+  }
+
+  // JwsSigning
+  if (!userConfig.HUB_ONLY_MODE) {
+    try {
+      await JwsSigning.sign(reqOpts)
+    } catch (err) {
+      customLogger.logMessage('error', 'JWS signing failed', { additionalData: err })
+    }
+  }
+  // Validate callback against openapi
+  if (callbackObject.method !== 'put') {
+    const validationResult = await context.api.validateRequest(callbackObject)
+    if (validationResult.valid) {
+      customLogger.logMessage('info', 'Callback schema is valid ' + callbackObject.method + ' ' + callbackObject.path, { request: req })
+    } else {
+      customLogger.logMessage('error', 'Callback schema is invalid ' + callbackObject.method + ' ' + callbackObject.path, { additionalData: validationResult.errors, request: req })
+    }
+  }
+  // Store callbacks for assertion
+  let assertionPath = callbackObject.path
+  const assertionData = { headers: callbackObject.headers, body: callbackObject.body }
+  if (assertionPath.endsWith('/error')) {
+    assertionPath = assertionPath.replace('/error', '')
+    assertionData.error = true
+  }
+  objectStore.push('callbacks', assertionPath, assertionData)
+  MyEventEmitter.getEmitter('assertionCallback', req.customInfo.user).emit(assertionPath, assertionData)
+
+  // Store all the callbacks in callbacksHistory
+  arrayStore.push('callbacksHistory', { timestamp: Date.now(), url: urlGenerated, method: callbackObject.method, path: callbackObject.path, headers: callbackObject.headers, body: callbackObject.body })
+
+  // Send callback
+  if (userConfig.SEND_CALLBACK_ENABLE) {
+    customLogger.logOutboundRequest('info', 'Request: ' + reqOpts.method + ' ' + reqOpts.path, { additionalData: { request: reqOpts }, request: reqOpts, uniqueId })
+    customLogger.logMessage('info', 'Sending callback ' + callbackObject.method + ' ' + reqOpts.url, { additionalData: callbackObject, request: req })
+    axios(reqOpts).then((result) => {
+      customLogger.logOutboundRequest('info', 'Response: ' + reqOpts.method + ' ' + reqOpts.path, { additionalData: { response: result }, request: reqOpts, uniqueId })
+      customLogger.logMessage('info', 'Received callback response ' + result.status + ' ' + result.statusText, { request: req })
+    }, (err) => {
+      customLogger.logOutboundRequest('error', 'Response: ' + reqOpts.method + ' ' + reqOpts.path, { additionalData: err.response, request: reqOpts, uniqueId })
+      customLogger.logMessage('error', 'Failed to send callback ' + callbackObject.method + ' ' + reqOpts.url, { additionalData: { message: err.message, responseData: (err.response && err.response.data) ? err.response.data : {} }, request: req })
+    })
+  } else {
+    customLogger.logMessage('info', 'Log callback ' + callbackObject.method + ' ' + callbackObject.path, { additionalData: callbackObject, request: req })
+  }
+}
+
+module.exports.handleCallback = handleCallback

package/src/lib/config.js

@@ -0,0 +1,177 @@
+/*****
+ 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
+ - Name Surname <name.surname@mojaloop.io>
+
+ * ModusBox
+ * Georgi Logodazhki <georgi.logodazhki@modusbox.com>
+ * Vijaya Kumar Guthi <vijaya.guthi@modusbox.com> (Original Author)
+ --------------
+ ******/
+
+const storageAdapter = require('./storageAdapter')
+const SYSTEM_CONFIG_FILE = 'spec_files/system_config.json'
+const USER_CONFIG_FILE = 'spec_files/user_config.json'
+const _ = require('lodash')
+
+let SYSTEM_CONFIG = {}
+
+const USER_CONFIG = {
+  data: undefined
+}
+
+const getSystemConfig = () => {
+  return SYSTEM_CONFIG
+}
+
+const getUserConfig = async (user) => {
+  const item = user ? user.dfspId : 'data'
+  if (!USER_CONFIG[item]) {
+    await loadUserConfig(user)
+  }
+  return USER_CONFIG[item]
+}
+
+const getStoredUserConfig = async (user) => {
+  try {
+    const storedConfig = await loadUserConfigDFSPWise(user)
+    return storedConfig
+  } catch (err) {
+    console.log(`Can not read the file ${USER_CONFIG_FILE}`, err)
+    return {}
+  }
+}
+
+const setStoredUserConfig = async (newConfig, user) => {
+  try {
+    await storageAdapter.upsert(USER_CONFIG_FILE, { ...getUserConfig(), ...newConfig }, user)
+    return true
+  } catch (err) {
+    return false
+  }
+}
+
+const loadUserConfig = async (user, filename = USER_CONFIG_FILE) => {
+  try {
+    USER_CONFIG[user ? user.dfspId : 'data'] = await loadUserConfigDFSPWise(user, filename)
+  } catch (err) {
+    console.log(`Can not read the file ${USER_CONFIG_FILE}`, err)
+  }
+  return true
+}
+
+const loadUserConfigDFSPWise = async (user, filename = USER_CONFIG_FILE) => {
+  const userConfig = await storageAdapter.read(filename, user)
+  return userConfig.data
+}
+
+const loadSystemConfig = async (filename = SYSTEM_CONFIG_FILE) => {
+  try {
+    SYSTEM_CONFIG = (await storageAdapter.read(filename)).data
+    const systemConfigFromEnvironment = _getSystemConfigFromEnvironment()
+    _.merge(SYSTEM_CONFIG, systemConfigFromEnvironment)
+    const secretsFromEnvironment = _getSecretsFromEnvironment()
+    console.log(secretsFromEnvironment)
+    _.merge(SYSTEM_CONFIG, secretsFromEnvironment)
+  } catch (err) {
+    console.log(`Can not read the file ${filename}`, err)
+  }
+  return true
+}
+
+const _getSecretsFromEnvironment = () => {
+  const secretsFromEnvironment = {}
+  if (process.env.REPORTING_DB_CONNECTION_PASSWORD || process.env.REPORTING_DB_CONNECTION_STRING) {
+    try {
+      const reportingDbConnectionPassword = process.env.REPORTING_DB_CONNECTION_PASSWORD
+      const reportingDbConnectionString = process.env.REPORTING_DB_CONNECTION_STRING
+      console.log(`Retrieved reporting database password in environment '${process.env.REPORTING_DB_CONNECTION_PASSWORD}'`)
+      console.log(`Retrieved reporting database connection string in environment '${process.env.REPORTING_DB_CONNECTION_STRING}'`)
+      secretsFromEnvironment.DB = {
+        PASSWORD: reportingDbConnectionPassword,
+        CONNECTION_STRING: reportingDbConnectionString
+      }
+      console.log(`Secrets retrieved from environment to be merged into system config ${secretsFromEnvironment}`)
+    } catch (err) {
+      console.log(err)
+      console.log('Failed to retrieve reporting database password or connection string in environment')
+    }
+  }
+  return secretsFromEnvironment
+}
+
+const _getSystemConfigFromEnvironment = () => {
+  let systemConfigFromEnvironment = {}
+  if (process.env.TTK_SYSTEM_CONFIG) {
+    try {
+      systemConfigFromEnvironment = JSON.parse(process.env.TTK_SYSTEM_CONFIG)
+    } catch (err) {
+      console.log(`Failed to parse system config passed in environment ${process.env.TTK_SYSTEM_CONFIG}`)
+    }
+  }
+  return systemConfigFromEnvironment
+}
+
+const setSystemConfig = async (newConfig) => {
+  try {
+    await storageAdapter.upsert(SYSTEM_CONFIG_FILE, { ...getSystemConfig(), ...newConfig })
+    await loadSystemConfig()
+    return true
+  } catch (err) {
+    return false
+  }
+}
+
+// const _getObjectStoreInitConfigFromEnvironment = () => {
+//   let objectStoreInitConfigFromEnvironment = {}
+//   if (process.env.TTK_OBJECT_STORE_INIT_CONFIG) {
+//     try {
+//       objectStoreInitConfigFromEnvironment = JSON.parse(process.env.TTK_OBJECT_STORE_INIT_CONFIG)
+//     } catch (err) {
+//       console.log(`Failed to parse objectStore init config passed in environment ${process.env.TTK_OBJECT_STORE_INIT_CONFIG}`)
+//     }
+//   }
+//   return objectStoreInitConfigFromEnvironment
+// }
+
+const _getObjectStoreInitConfigFromSystemConfig = () => {
+  let objectStoreInitConfigFromSystemConfig = {}
+  if (SYSTEM_CONFIG.INIT_CONFIG && SYSTEM_CONFIG.INIT_CONFIG.objectStore) {
+    objectStoreInitConfigFromSystemConfig = SYSTEM_CONFIG.INIT_CONFIG.objectStore
+  }
+  return objectStoreInitConfigFromSystemConfig
+}
+
+const getObjectStoreInitConfig = async () => {
+  return _getObjectStoreInitConfigFromSystemConfig()
+}
+
+module.exports = {
+  getUserConfig,
+  getStoredUserConfig,
+  setStoredUserConfig,
+  loadUserConfig,
+  getSystemConfig,
+  loadSystemConfig,
+  setSystemConfig,
+  getObjectStoreInitConfig
+}