@tradejs/infra 1.0.9 → 1.0.10

package/dist/tradingAccounts.mjs

@@ -0,0 +1,190 @@
+import {
+  delKey,
+  getData,
+  getKeys,
+  redisKeys,
+  setData
+} from "./chunk-DXG2UDNA.mjs";
+
+// src/tradingAccounts.ts
+var normalizeId = (value, label) => {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+  if (!normalized) {
+    throw new Error(`${label} is required`);
+  }
+  return normalized;
+};
+var isTradingAccount = (value) => Boolean(
+  value && typeof value === "object" && typeof value.id === "string" && typeof value.provider === "string"
+);
+var isRuntimeDeployment = (value) => Boolean(
+  value && typeof value === "object" && typeof value.id === "string" && typeof value.accountId === "string"
+);
+var withProviderUniverses = (account) => account.provider.toLowerCase() === "bybit" ? { ...account, universes: ["crypto", "tradfi"] } : account;
+var listTradingAccounts = async (userName) => {
+  if (typeof redisKeys.tradingAccounts !== "function") return [];
+  const keys = await getKeys(redisKeys.tradingAccounts(userName));
+  const values = await Promise.all(keys.map((key) => getData(key, null)));
+  return values.filter(isTradingAccount).map(withProviderUniverses).sort((left, right) => left.label.localeCompare(right.label));
+};
+var getTradingAccount = async (userName, accountId) => {
+  const normalizedId = normalizeId(accountId, "Account id");
+  const value = await getData(
+    redisKeys.tradingAccount(userName, normalizedId),
+    null
+  );
+  return isTradingAccount(value) ? withProviderUniverses(value) : null;
+};
+var saveTradingAccount = async (userName, account) => {
+  const normalized = withProviderUniverses({
+    ...account,
+    id: normalizeId(account.id, "Account id"),
+    label: account.label.trim(),
+    provider: account.provider.trim().toLowerCase(),
+    universes: [...new Set(account.universes)]
+  });
+  if (normalized.isDefault) {
+    const previousDefaults = (await listTradingAccounts(userName)).filter(
+      (candidate) => candidate.provider === normalized.provider && candidate.id !== normalized.id && candidate.isDefault && candidate.universes.some(
+        (universe) => normalized.universes.includes(universe)
+      )
+    );
+    await Promise.all(
+      previousDefaults.map(
+        (candidate) => setData(
+          redisKeys.tradingAccount(userName, candidate.id),
+          { ...candidate, isDefault: false },
+          { expire: 0 }
+        )
+      )
+    );
+  }
+  await setData(redisKeys.tradingAccount(userName, normalized.id), normalized, {
+    expire: 0
+  });
+  return normalized;
+};
+var deleteTradingAccount = async (userName, accountId) => delKey(
+  redisKeys.tradingAccount(userName, normalizeId(accountId, "Account id"))
+);
+var resolveTradingAccount = async ({
+  userName,
+  accountId,
+  provider,
+  universe
+}) => {
+  if (accountId) {
+    const account = await getTradingAccount(userName, accountId);
+    if (!account) {
+      throw new Error(`Trading account not found: ${accountId}`);
+    }
+    if (account.provider !== provider.toLowerCase()) {
+      throw new Error(
+        `Trading account ${accountId} belongs to ${account.provider}, not ${provider}`
+      );
+    }
+    if (!account.enabled) {
+      throw new Error(`Trading account is disabled: ${accountId}`);
+    }
+    if (universe && !account.universes.includes(universe)) {
+      throw new Error(
+        `Trading account ${accountId} does not support universe ${universe}`
+      );
+    }
+    return account;
+  }
+  const accounts = (await listTradingAccounts(userName)).filter(
+    (account) => account.enabled && account.provider === provider.toLowerCase() && (!universe || account.universes.includes(universe))
+  );
+  const selected = accounts.find((account) => account.isDefault) ?? (accounts.length === 1 ? accounts[0] : null);
+  if (selected) return selected;
+  if (provider.toLowerCase() !== "bybit" || accounts.length > 1) {
+    return null;
+  }
+  const legacy = await getData(redisKeys.user(userName));
+  const legacyApiKey = String(legacy?.BYBIT_API_KEY ?? "").trim();
+  const legacyApiSecret = String(legacy?.BYBIT_API_SECRET ?? "").trim();
+  if (!legacyApiKey || !legacyApiSecret) {
+    return null;
+  }
+  return {
+    id: "bybit-default",
+    label: "Bybit Default",
+    provider: "bybit",
+    enabled: true,
+    isDefault: true,
+    universes: ["crypto", "tradfi"],
+    environment: "mainnet",
+    apiKey: legacyApiKey,
+    apiSecret: legacyApiSecret
+  };
+};
+var listRuntimeDeployments = async (userName) => {
+  const keys = await getKeys(redisKeys.runtimeDeployments(userName));
+  const values = await Promise.all(keys.map((key) => getData(key, null)));
+  return values.filter(isRuntimeDeployment).sort((left, right) => left.label.localeCompare(right.label));
+};
+var getRuntimeDeployment = async (userName, deploymentId) => {
+  const normalizedId = normalizeId(deploymentId, "Deployment id");
+  const value = await getData(
+    redisKeys.runtimeDeployment(userName, normalizedId),
+    null
+  );
+  return isRuntimeDeployment(value) ? value : null;
+};
+var saveRuntimeDeployment = async (userName, deployment) => {
+  const normalized = {
+    ...deployment,
+    id: normalizeId(deployment.id, "Deployment id"),
+    label: deployment.label.trim(),
+    provider: deployment.provider.trim().toLowerCase(),
+    accountId: normalizeId(deployment.accountId, "Account id")
+  };
+  await setData(
+    redisKeys.runtimeDeployment(userName, normalized.id),
+    normalized,
+    { expire: 0 }
+  );
+  return normalized;
+};
+var deleteRuntimeDeployment = async (userName, deploymentId) => {
+  const normalizedId = normalizeId(deploymentId, "Deployment id");
+  await Promise.all([
+    delKey(redisKeys.runtimeDeployment(userName, normalizedId)),
+    delKey(redisKeys.runtimeDeploymentHeartbeat(userName, normalizedId))
+  ]);
+};
+var getRuntimeDeploymentHeartbeat = async (userName, deploymentId) => {
+  const value = await getData(
+    redisKeys.runtimeDeploymentHeartbeat(
+      userName,
+      normalizeId(deploymentId, "Deployment id")
+    ),
+    null
+  );
+  return value && typeof value === "object" ? value : null;
+};
+var saveRuntimeDeploymentHeartbeat = async (userName, heartbeat) => {
+  await setData(
+    redisKeys.runtimeDeploymentHeartbeat(
+      userName,
+      normalizeId(heartbeat.deploymentId, "Deployment id")
+    ),
+    heartbeat,
+    { expire: 0 }
+  );
+  return heartbeat;
+};
+export {
+  deleteRuntimeDeployment,
+  deleteTradingAccount,
+  getRuntimeDeployment,
+  getRuntimeDeploymentHeartbeat,
+  getTradingAccount,
+  listRuntimeDeployments,
+  listTradingAccounts,
+  resolveTradingAccount,
+  saveRuntimeDeployment,
+  saveRuntimeDeploymentHeartbeat,
+  saveTradingAccount
+};

package/dist/userSettings.d.mts

@@ -4,6 +4,7 @@ interface UserRecord extends Record<string, unknown> {
     BYBIT_API_KEY?: string;
     BYBIT_API_SECRET?: string;
     COINALYZE_API_KEY?: string;
+    COINMARKETCAP_API_KEY?: string;
     AI_API_KEY?: string;
     AI_API_ENDPOINT?: string;
     AI_MODEL?: string;
@@ -17,6 +18,7 @@ interface UserSettings {
     BYBIT_API_KEY: string;
     BYBIT_API_SECRET: string;
     COINALYZE_API_KEY: string;
+    COINMARKETCAP_API_KEY: string;
     AI_API_KEY: string;
     AI_API_ENDPOINT: string;
     AI_MODEL: string;

package/dist/userSettings.d.ts

@@ -4,6 +4,7 @@ interface UserRecord extends Record<string, unknown> {
     BYBIT_API_KEY?: string;
     BYBIT_API_SECRET?: string;
     COINALYZE_API_KEY?: string;
+    COINMARKETCAP_API_KEY?: string;
     AI_API_KEY?: string;
     AI_API_ENDPOINT?: string;
     AI_MODEL?: string;
@@ -17,6 +18,7 @@ interface UserSettings {
     BYBIT_API_KEY: string;
     BYBIT_API_SECRET: string;
     COINALYZE_API_KEY: string;
+    COINMARKETCAP_API_KEY: string;
     AI_API_KEY: string;
     AI_API_ENDPOINT: string;
     AI_MODEL: string;

package/dist/userSettings.js

@@ -354,9 +354,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;
@@ -538,13 +541,21 @@ var setData = async (key, data, options = {}) => {
 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`,
@@ -553,6 +564,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}`,
@@ -568,12 +580,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}`,
@@ -605,6 +623,7 @@ var getUserSettings = async (userName) => {
     BYBIT_API_KEY: readUserString(record, "BYBIT_API_KEY"),
     BYBIT_API_SECRET: readUserString(record, "BYBIT_API_SECRET"),
     COINALYZE_API_KEY: readUserString(record, "COINALYZE_API_KEY"),
+    COINMARKETCAP_API_KEY: readUserString(record, "COINMARKETCAP_API_KEY"),
     AI_API_KEY: readUserString(record, "AI_API_KEY"),
     AI_API_ENDPOINT: aiApiEndpoint,
     AI_MODEL: normalizeAiModel(

package/dist/userSettings.mjs

@@ -2,7 +2,7 @@ import {
   getData,
   redisKeys,
   setData
-} from "./chunk-MLVWC2I2.mjs";
+} from "./chunk-DXG2UDNA.mjs";
 import {
   DEFAULT_AI_RESPONSE_LANGUAGE,
   normalizeAiResponseLanguage
@@ -34,6 +34,7 @@ var getUserSettings = async (userName) => {
     BYBIT_API_KEY: readUserString(record, "BYBIT_API_KEY"),
     BYBIT_API_SECRET: readUserString(record, "BYBIT_API_SECRET"),
     COINALYZE_API_KEY: readUserString(record, "COINALYZE_API_KEY"),
+    COINMARKETCAP_API_KEY: readUserString(record, "COINMARKETCAP_API_KEY"),
     AI_API_KEY: readUserString(record, "AI_API_KEY"),
     AI_API_ENDPOINT: aiApiEndpoint,
     AI_MODEL: normalizeAiModel(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/infra",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Server-only infrastructure adapters for the TradeJS open-source framework: Redis, Timescale, ML, logging, and IO.",
   "keywords": [
     "tradejs",
@@ -13,7 +13,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tradejs-dev/tradejs.git",
+    "url": "https://github.com/TradeJS-Dev/TradeJS",
     "directory": "packages/infra"
   },
   "bugs": {
@@ -44,6 +44,11 @@
       "import": "./dist/aiModels.mjs",
       "require": "./dist/aiModels.js"
     },
+    "./backtestArtifacts": {
+      "types": "./dist/backtestArtifacts.d.ts",
+      "import": "./dist/backtestArtifacts.mjs",
+      "require": "./dist/backtestArtifacts.js"
+    },
     "./files": {
       "types": "./dist/files.d.ts",
       "import": "./dist/files.mjs",
@@ -78,12 +83,17 @@
       "types": "./dist/timescale.d.ts",
       "import": "./dist/timescale.mjs",
       "require": "./dist/timescale.js"
+    },
+    "./tradingAccounts": {
+      "types": "./dist/tradingAccounts.d.ts",
+      "import": "./dist/tradingAccounts.mjs",
+      "require": "./dist/tradingAccounts.js"
     }
   },
   "dependencies": {
     "@grpc/grpc-js": "^1.10.7",
     "@grpc/proto-loader": "^0.8.0",
-    "@tradejs/types": "^1.0.9",
+    "@tradejs/types": "^1.0.10",
     "chalk": "4.1.2",
     "ioredis": "5.8.0",
     "pg": "8.16.3",