@tradejs/infra 1.0.9 → 1.0.10

package/dist/backtestArtifacts.js

@@ -0,0 +1,255 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backtestArtifacts.ts
+var backtestArtifacts_exports = {};
+__export(backtestArtifacts_exports, {
+  deleteCachedBacktestArtifacts: () => deleteCachedBacktestArtifacts,
+  deletePersistedBacktestOrderLog: () => deletePersistedBacktestOrderLog,
+  getBacktestArtifactsRootDir: () => getBacktestArtifactsRootDir,
+  getBacktestCacheArtifactsDirForUser: () => getBacktestCacheArtifactsDirForUser,
+  getPersistedBacktestArtifactsDirForUser: () => getPersistedBacktestArtifactsDirForUser,
+  parseBacktestArtifactRef: () => parseBacktestArtifactRef,
+  readCachedBacktestArtifacts: () => readCachedBacktestArtifacts,
+  readPersistedBacktestOrderLog: () => readPersistedBacktestOrderLog,
+  writeCachedBacktestArtifacts: () => writeCachedBacktestArtifacts,
+  writePersistedBacktestOrderLog: () => writePersistedBacktestOrderLog
+});
+module.exports = __toCommonJS(backtestArtifacts_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var BACKTEST_ARTIFACTS_DIR = import_path.default.join("data", "backtests");
+var resolveProjectRoot = (projectRoot) => {
+  const explicit = String(projectRoot || "").trim();
+  if (explicit) {
+    return import_path.default.resolve(explicit);
+  }
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  if (fromEnv) {
+    return import_path.default.resolve(fromEnv);
+  }
+  return process.cwd();
+};
+var encodeSegment = (value) => encodeURIComponent(String(value));
+var toProjectRelativePath = (projectRoot, absolutePath) => import_path.default.relative(projectRoot, absolutePath);
+var resolveArtifactPath = (relativePath, projectRoot) => {
+  const root = resolveProjectRoot(projectRoot);
+  return import_path.default.isAbsolute(relativePath) ? relativePath : import_path.default.resolve(root, relativePath);
+};
+var isEnoentError = (error) => error?.code === "ENOENT";
+var createRef = (absolutePath, projectRoot) => ({
+  kind: "file",
+  version: 1,
+  path: toProjectRelativePath(resolveProjectRoot(projectRoot), absolutePath)
+});
+var isBacktestArtifactRef = (value) => Boolean(
+  value && typeof value === "object" && value.kind === "file" && value.version === 1 && typeof value.path === "string"
+);
+var getCachedArtifactPath = (userName, orderLogId, artifactName, projectRoot) => import_path.default.join(
+  resolveProjectRoot(projectRoot),
+  BACKTEST_ARTIFACTS_DIR,
+  "cache",
+  encodeSegment(userName),
+  artifactName,
+  `${encodeSegment(orderLogId)}.json`
+);
+var getPersistedOrderLogPath = (userName, strategyName, testName, projectRoot) => import_path.default.join(
+  resolveProjectRoot(projectRoot),
+  BACKTEST_ARTIFACTS_DIR,
+  "tests",
+  encodeSegment(userName),
+  encodeSegment(strategyName),
+  `${encodeSegment(testName)}.json`
+);
+var readJsonFile = async (absolutePath, fallback) => {
+  try {
+    const raw = await import_promises.default.readFile(absolutePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return fallback;
+    }
+    throw error;
+  }
+};
+var writeJsonFile = async (absolutePath, value) => {
+  await import_promises.default.mkdir(import_path.default.dirname(absolutePath), { recursive: true });
+  await import_promises.default.writeFile(absolutePath, JSON.stringify(value), "utf8");
+};
+var removeFileIfExists = async (absolutePath) => {
+  try {
+    await import_promises.default.rm(absolutePath, { force: true });
+    return true;
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return false;
+    }
+    throw error;
+  }
+};
+var writeCachedBacktestArtifacts = async ({
+  orderLog,
+  orderLogId,
+  positionLog,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  await Promise.all([
+    writeJsonFile(orderPath, orderLog),
+    writeJsonFile(positionPath, positionLog)
+  ]);
+  return {
+    orderLog: createRef(orderPath, projectRoot),
+    positionLog: createRef(positionPath, projectRoot)
+  };
+};
+var readCachedBacktestArtifacts = async ({
+  orderLogId,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  const [orderLog, positionLog] = await Promise.all([
+    readJsonFile(orderPath, null),
+    readJsonFile(positionPath, null)
+  ]);
+  return { orderLog, positionLog };
+};
+var deleteCachedBacktestArtifacts = async ({
+  orderLogId,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  const [removedOrderLog, removedPositionLog] = await Promise.all([
+    removeFileIfExists(orderPath),
+    removeFileIfExists(positionPath)
+  ]);
+  return removedOrderLog || removedPositionLog;
+};
+var writePersistedBacktestOrderLog = async ({
+  orderLog,
+  projectRoot,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = getPersistedOrderLogPath(
+    userName,
+    strategyName,
+    testName,
+    projectRoot
+  );
+  await writeJsonFile(absolutePath, orderLog);
+  return createRef(absolutePath, projectRoot);
+};
+var readPersistedBacktestOrderLog = async ({
+  projectRoot,
+  ref,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = ref ? resolveArtifactPath(ref.path, projectRoot) : getPersistedOrderLogPath(userName, strategyName, testName, projectRoot);
+  return readJsonFile(absolutePath, null);
+};
+var deletePersistedBacktestOrderLog = async ({
+  projectRoot,
+  ref,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = ref ? resolveArtifactPath(ref.path, projectRoot) : getPersistedOrderLogPath(userName, strategyName, testName, projectRoot);
+  return removeFileIfExists(absolutePath);
+};
+var parseBacktestArtifactRef = (value) => {
+  if (isBacktestArtifactRef(value)) {
+    return value;
+  }
+  return null;
+};
+var getBacktestArtifactsRootDir = (projectRoot) => import_path.default.join(resolveProjectRoot(projectRoot), BACKTEST_ARTIFACTS_DIR);
+var getBacktestCacheArtifactsDirForUser = (userName, projectRoot) => import_path.default.join(
+  getBacktestArtifactsRootDir(projectRoot),
+  "cache",
+  encodeSegment(userName)
+);
+var getPersistedBacktestArtifactsDirForUser = (userName, projectRoot) => import_path.default.join(
+  getBacktestArtifactsRootDir(projectRoot),
+  "tests",
+  encodeSegment(userName)
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteCachedBacktestArtifacts,
+  deletePersistedBacktestOrderLog,
+  getBacktestArtifactsRootDir,
+  getBacktestCacheArtifactsDirForUser,
+  getPersistedBacktestArtifactsDirForUser,
+  parseBacktestArtifactRef,
+  readCachedBacktestArtifacts,
+  readPersistedBacktestOrderLog,
+  writeCachedBacktestArtifacts,
+  writePersistedBacktestOrderLog
+});

package/dist/backtestArtifacts.mjs

@@ -0,0 +1,211 @@
+// src/backtestArtifacts.ts
+import fs from "fs/promises";
+import path from "path";
+var BACKTEST_ARTIFACTS_DIR = path.join("data", "backtests");
+var resolveProjectRoot = (projectRoot) => {
+  const explicit = String(projectRoot || "").trim();
+  if (explicit) {
+    return path.resolve(explicit);
+  }
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  if (fromEnv) {
+    return path.resolve(fromEnv);
+  }
+  return process.cwd();
+};
+var encodeSegment = (value) => encodeURIComponent(String(value));
+var toProjectRelativePath = (projectRoot, absolutePath) => path.relative(projectRoot, absolutePath);
+var resolveArtifactPath = (relativePath, projectRoot) => {
+  const root = resolveProjectRoot(projectRoot);
+  return path.isAbsolute(relativePath) ? relativePath : path.resolve(root, relativePath);
+};
+var isEnoentError = (error) => error?.code === "ENOENT";
+var createRef = (absolutePath, projectRoot) => ({
+  kind: "file",
+  version: 1,
+  path: toProjectRelativePath(resolveProjectRoot(projectRoot), absolutePath)
+});
+var isBacktestArtifactRef = (value) => Boolean(
+  value && typeof value === "object" && value.kind === "file" && value.version === 1 && typeof value.path === "string"
+);
+var getCachedArtifactPath = (userName, orderLogId, artifactName, projectRoot) => path.join(
+  resolveProjectRoot(projectRoot),
+  BACKTEST_ARTIFACTS_DIR,
+  "cache",
+  encodeSegment(userName),
+  artifactName,
+  `${encodeSegment(orderLogId)}.json`
+);
+var getPersistedOrderLogPath = (userName, strategyName, testName, projectRoot) => path.join(
+  resolveProjectRoot(projectRoot),
+  BACKTEST_ARTIFACTS_DIR,
+  "tests",
+  encodeSegment(userName),
+  encodeSegment(strategyName),
+  `${encodeSegment(testName)}.json`
+);
+var readJsonFile = async (absolutePath, fallback) => {
+  try {
+    const raw = await fs.readFile(absolutePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return fallback;
+    }
+    throw error;
+  }
+};
+var writeJsonFile = async (absolutePath, value) => {
+  await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+  await fs.writeFile(absolutePath, JSON.stringify(value), "utf8");
+};
+var removeFileIfExists = async (absolutePath) => {
+  try {
+    await fs.rm(absolutePath, { force: true });
+    return true;
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return false;
+    }
+    throw error;
+  }
+};
+var writeCachedBacktestArtifacts = async ({
+  orderLog,
+  orderLogId,
+  positionLog,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  await Promise.all([
+    writeJsonFile(orderPath, orderLog),
+    writeJsonFile(positionPath, positionLog)
+  ]);
+  return {
+    orderLog: createRef(orderPath, projectRoot),
+    positionLog: createRef(positionPath, projectRoot)
+  };
+};
+var readCachedBacktestArtifacts = async ({
+  orderLogId,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  const [orderLog, positionLog] = await Promise.all([
+    readJsonFile(orderPath, null),
+    readJsonFile(positionPath, null)
+  ]);
+  return { orderLog, positionLog };
+};
+var deleteCachedBacktestArtifacts = async ({
+  orderLogId,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  const [removedOrderLog, removedPositionLog] = await Promise.all([
+    removeFileIfExists(orderPath),
+    removeFileIfExists(positionPath)
+  ]);
+  return removedOrderLog || removedPositionLog;
+};
+var writePersistedBacktestOrderLog = async ({
+  orderLog,
+  projectRoot,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = getPersistedOrderLogPath(
+    userName,
+    strategyName,
+    testName,
+    projectRoot
+  );
+  await writeJsonFile(absolutePath, orderLog);
+  return createRef(absolutePath, projectRoot);
+};
+var readPersistedBacktestOrderLog = async ({
+  projectRoot,
+  ref,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = ref ? resolveArtifactPath(ref.path, projectRoot) : getPersistedOrderLogPath(userName, strategyName, testName, projectRoot);
+  return readJsonFile(absolutePath, null);
+};
+var deletePersistedBacktestOrderLog = async ({
+  projectRoot,
+  ref,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = ref ? resolveArtifactPath(ref.path, projectRoot) : getPersistedOrderLogPath(userName, strategyName, testName, projectRoot);
+  return removeFileIfExists(absolutePath);
+};
+var parseBacktestArtifactRef = (value) => {
+  if (isBacktestArtifactRef(value)) {
+    return value;
+  }
+  return null;
+};
+var getBacktestArtifactsRootDir = (projectRoot) => path.join(resolveProjectRoot(projectRoot), BACKTEST_ARTIFACTS_DIR);
+var getBacktestCacheArtifactsDirForUser = (userName, projectRoot) => path.join(
+  getBacktestArtifactsRootDir(projectRoot),
+  "cache",
+  encodeSegment(userName)
+);
+var getPersistedBacktestArtifactsDirForUser = (userName, projectRoot) => path.join(
+  getBacktestArtifactsRootDir(projectRoot),
+  "tests",
+  encodeSegment(userName)
+);
+export {
+  deleteCachedBacktestArtifacts,
+  deletePersistedBacktestOrderLog,
+  getBacktestArtifactsRootDir,
+  getBacktestCacheArtifactsDirForUser,
+  getPersistedBacktestArtifactsDirForUser,
+  parseBacktestArtifactRef,
+  readCachedBacktestArtifacts,
+  readPersistedBacktestOrderLog,
+  writeCachedBacktestArtifacts,
+  writePersistedBacktestOrderLog
+};

package/dist/{chunk-MLVWC2I2.mjs → chunk-DXG2UDNA.mjs}

@@ -12,9 +12,12 @@ var logger = {
 };
 var redisConnectionWarningShown = false;
 var redisUnavailable = false;
-var isRedisConnectivityError = (error) => /ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|MaxRetriesPerRequestError|Connection is closed|Stream isn't writeable/i.test(
-  error.message
-);
+var isRedisConnectivityError = (error) => {
+  const errorText = [error.name, error.message, String(error)].join(" ");
+  return /ECONNREFUSED|ECONNRESET|ECONNABORTED|EPIPE|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|MaxRetriesPerRequestError|Connection is closed|Stream isn't writeable/i.test(
+    errorText
+  );
+};
 var toNonNegativeInt = (value, fallback) => {
   const parsed = Number.parseInt(String(value ?? ""), 10);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
@@ -70,6 +73,16 @@ var getRedis = () => {
   }
   return global.__redis__;
 };
+var closeRedisConnection = async () => {
+  const redis = global.__redis__;
+  if (!redis) {
+    return;
+  }
+  global.__redis__ = void 0;
+  redisUnavailable = false;
+  redisConnectionWarningShown = false;
+  redis.disconnect();
+};
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var getRedisStatus = (redis) => String(redis.status ?? "ready");
 var waitForRedisReady = async (redis) => {
@@ -110,6 +123,11 @@ var toResultString = (result) => {
   if (Buffer.isBuffer(result)) return result.toString("utf8");
   return String(result);
 };
+var publishData = async (channel, value) => {
+  const redis = await getReadyRedis();
+  if (!redis) return 0;
+  return redis.publish(channel, toJson(value));
+};
 var DEFAULT_OPTIONS = {
   expire: TTL_1D
 };
@@ -301,6 +319,25 @@ var setHashJsonField = async (key, field, data, options = {}) => {
     logger.log("error", "failed HSET %s[%s]: %s", key, field, String(e));
   }
 };
+var getHashJsonField = async (key, field, fallback = null) => {
+  if (redisUnavailable) return fallback;
+  const redis = await getReadyRedis();
+  if (!redis) return fallback;
+  try {
+    const value = await redis.call("HGET", key, field);
+    if (typeof value !== "string" || !value) {
+      return fallback;
+    }
+    return JSON.parse(value);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return fallback;
+    }
+    logger.log("error", "failed HGET %s[%s]: %s", key, field, String(e));
+    return fallback;
+  }
+};
 var getHashJsonValues = async (key) => {
   if (redisUnavailable) return [];
   const redis = await getReadyRedis();
@@ -406,13 +443,21 @@ var consumeScreenshotSessionToken = async (token) => {
 var redisKeys = {
   users: () => "users:index:",
   user: (userName) => `users:index:${userName}`,
+  tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
+  tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
+  runtimeDeployments: (userName) => `users:${userName}:runtime:deployments:`,
+  runtimeDeployment: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}`,
+  runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
   bots: (userName) => `users:${userName}:bots`,
   botsPrefix: () => "users:",
   bot: (userName, botId) => `users:${userName}:bots:${botId}`,
   backtestConfig: (userName, config) => `users:${userName}:backtests:configs:${config}`,
   strategies: (userName) => `users:${userName}:strategies`,
-  strategyConfig: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:config`,
+  strategyConfig: (userName, strategyName, configId = "config") => `users:${userName}:strategies:${strategyName}:${configId}`,
   strategyResults: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:results`,
+  strategyCharts: (userName, mode) => `users:${userName}:strategies:charts:${mode}`,
+  strategyChartCards: (userName, mode) => `users:${userName}:strategies:charts:${mode}:cards:`,
+  strategyChartCard: (userName, mode, cardId) => `users:${userName}:strategies:charts:${mode}:cards:${cardId}`,
   tests: (userName, strategyName) => strategyName ? `users:${userName}:tests:${strategyName}` : `users:${userName}:tests:`,
   testOrders: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:orders`,
   testConfig: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:config`,
@@ -421,6 +466,7 @@ var redisKeys = {
   cacheChunk: (userName, chunkId) => `users:${userName}:cache:tests:chunks:${chunkId}`,
   cacheOrders: (userName, orderLogId) => `users:${userName}:cache:tests:orders:${orderLogId}`,
   cachePositions: (userName, orderLogId) => `users:${userName}:cache:tests:positions:${orderLogId}`,
+  tickerUniverse: (userName, connectorName, universe, accountId) => universe || accountId ? `users:${userName}:cache:tickers:${connectorName}:${universe ?? "crypto"}:${accountId ?? "default"}` : `users:${userName}:cache:tickers:${connectorName}`,
   signal: (symbol, signalId) => `signals:${symbol}:${signalId}`,
   signalsBySymbol: (symbol) => `signals:${symbol}:`,
   storeSignal: (symbol, signalId) => `store:signals:${symbol}:${signalId}`,
@@ -436,12 +482,18 @@ var redisKeys = {
   runtimeSignalEvaluationStatsBucket: (userName, dayKey, strategyName) => `users:${userName}:runtime:signal-evaluation-stats:days:${dayKey}:${strategyName}`,
   runtimeTrades: (userName) => `users:${userName}:runtime:trade-records:`,
   runtimeTrade: (userName, orderId) => `users:${userName}:runtime:trade-records:${orderId}`,
+  runtimeTradeBuckets: (userName) => `users:${userName}:runtime:trade-records:days:`,
+  runtimeTradeBucket: (userName, dayKey) => `users:${userName}:runtime:trade-records:days:${dayKey}`,
   runtimeActiveTrades: (userName) => `users:${userName}:runtime:active-trades:`,
-  runtimeActiveTrade: (userName, symbol) => `users:${userName}:runtime:active-trades:${symbol}`,
+  runtimeActiveTrade: (userName, symbol, scopeId) => scopeId ? `users:${userName}:runtime:active-trades:${scopeId}:${symbol}` : `users:${userName}:runtime:active-trades:${symbol}`,
   aiChatHistory: (userName, symbolKey) => `users:${userName}:ai:chats:${symbolKey}`,
   analysis: (symbol, signalId) => `analysis:${symbol}:${signalId}`,
   screenshotSessionToken: (token) => `auth:screenshot:${token}`,
   backtestResults: (userName, config, timestamp) => `users:${userName}:backtests:results:${config}:${timestamp}`,
+  backtestRuns: (userName) => `users:${userName}:backtests:runs:`,
+  backtestRun: (userName, runId) => `users:${userName}:backtests:runs:${runId}`,
+  backtestRunResults: (userName, runId) => `users:${userName}:backtests:runs:${runId}:results`,
+  backtestLatestRun: (userName, config) => `users:${userName}:backtests:latest:${config}`,
   researchRuns: (userName) => `users:${userName}:research:runs:`,
   researchRun: (userName, runId) => `users:${userName}:research:runs:${runId}`,
   researchLatestRun: (userName, strategyName) => `users:${userName}:research:latest:${strategyName}`,
@@ -454,6 +506,8 @@ var redisKeys = {
 };
 
 export {
+  closeRedisConnection,
+  publishData,
   getKeys,
   getData,
   delKey,
@@ -461,6 +515,7 @@ export {
   delKeyWithOptions,
   setData,
   setHashJsonField,
+  getHashJsonField,
   getHashJsonValues,
   incrHashFields,
   getHashData,